diff options
Diffstat (limited to 'drivers/media/video/samsung/mali/common')
50 files changed, 695 insertions, 696 deletions
diff --git a/drivers/media/video/samsung/mali/common/mali_block_allocator.c b/drivers/media/video/samsung/mali/common/mali_block_allocator.c index 269e662..269e662 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_block_allocator.c +++ b/drivers/media/video/samsung/mali/common/mali_block_allocator.c diff --git a/drivers/media/video/samsung/mali/common/mali_block_allocator.h b/drivers/media/video/samsung/mali/common/mali_block_allocator.h index d3f0f9b..6c6f13e 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_block_allocator.h +++ b/drivers/media/video/samsung/mali/common/mali_block_allocator.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010 ARM Limited. All rights reserved. + * Copyright (C) 2010, 2012 ARM Limited. All rights reserved. * * This program is free software and is provided to you under the terms of the GNU General Public License version 2 * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. diff --git a/drivers/media/video/samsung/mali/common/mali_device_pause_resume.c b/drivers/media/video/samsung/mali/common/mali_device_pause_resume.c index 6af1279..6af1279 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_device_pause_resume.c +++ b/drivers/media/video/samsung/mali/common/mali_device_pause_resume.c diff --git a/drivers/media/video/samsung/mali/common/mali_device_pause_resume.h b/drivers/media/video/samsung/mali/common/mali_device_pause_resume.h index 6be75b0..6be75b0 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_device_pause_resume.h +++ b/drivers/media/video/samsung/mali/common/mali_device_pause_resume.h diff --git a/drivers/media/video/samsung/mali/common/mali_gp.c b/drivers/media/video/samsung/mali/common/mali_gp.c index d03721c..2110471 100644 --- a/drivers/media/video/samsung/mali/common/mali_gp.c +++ b/drivers/media/video/samsung/mali/common/mali_gp.c @@ -298,6 +298,14 @@ void mali_gp_job_start(struct mali_gp_core *core, struct mali_gp_job *job) mali_hw_core_register_write_array_relaxed(&core->hw_core, MALIGP2_REG_ADDR_MGMT_VSCL_START_ADDR, frame_registers, MALIGP2_NUM_REGS_FRAME); +#if PROFILING_PRINT_L2_HITRATE_ON_GP_FINISH + { + /* Read hits and Read misses*/ + mali_l2_cache_core_set_counter_src0(mali_l2_cache_core_get_glob_l2_core(0), 20); + mali_l2_cache_core_set_counter_src1(mali_l2_cache_core_get_glob_l2_core(0), 21); + } +#endif + /* This selects which performance counters we are reading */ if (MALI_HW_CORE_NO_COUNTER != core->counter_src0_used || MALI_HW_CORE_NO_COUNTER != core->counter_src0_used) { @@ -353,8 +361,8 @@ void mali_gp_job_start(struct mali_gp_core *core, struct mali_gp_job *job) #if MALI_TIMELINE_PROFILING_ENABLED _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_SINGLE | MALI_PROFILING_MAKE_EVENT_CHANNEL_GP(0) | MALI_PROFILING_EVENT_REASON_SINGLE_HW_FLUSH, - job->frame_builder_id, job->flush_id, 0, 0, 0); - _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_START|MALI_PROFILING_MAKE_EVENT_CHANNEL_GP(0), job->pid, job->tid, 0, 0, 0); + mali_gp_job_get_frame_builder_id(job), mali_gp_job_get_flush_id(job), 0, 0, 0); + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_START|MALI_PROFILING_MAKE_EVENT_CHANNEL_GP(0), mali_gp_job_get_pid(job), mali_gp_job_get_tid(job), 0, 0, 0); #endif core->running_job = job; @@ -472,9 +480,7 @@ static void mali_gp_bottom_half(void *data) u32 irq_errors; #if MALI_TIMELINE_PROFILING_ENABLED -#if 0 /* Bottom half TLP logging is currently not supported */ - _mali_osk_profiling_add_event( MALI_PROFILING_EVENT_TYPE_START| MALI_PROFILING_EVENT_CHANNEL_SOFTWARE , _mali_osk_get_pid(), _mali_osk_get_tid()+11000, 0, 0, 0); -#endif + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_START|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), MALI_PROFILING_MAKE_EVENT_DATA_CORE_GP(0), 0, 0); #endif mali_group_lock(core->group); /* Group lock grabbed in core handlers, but released in common group handler */ @@ -483,6 +489,9 @@ static void mali_gp_bottom_half(void *data) { MALI_PRINT_ERROR(("Interrupt bottom half of %s when core is OFF.", core->hw_core.description)); mali_group_unlock(core->group); +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } @@ -497,6 +506,9 @@ static void mali_gp_bottom_half(void *data) mali_gp_post_process_job(core, MALI_FALSE); MALI_DEBUG_PRINT(4, ("Mali GP: Job completed, calling group handler\n")); mali_group_bottom_half(core->group, GROUP_EVENT_GP_JOB_COMPLETED); /* Will release group lock */ +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } } @@ -511,6 +523,9 @@ static void mali_gp_bottom_half(void *data) mali_gp_post_process_job(core, MALI_FALSE); MALI_PRINT_ERROR(("Mali GP: Unknown interrupt 0x%08X from core %s, aborting job\n", irq_readout, core->hw_core.description)); mali_group_bottom_half(core->group, GROUP_EVENT_GP_JOB_FAILED); /* Will release group lock */ +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } else if (MALI_TRUE == core->core_timed_out) /* SW timeout */ @@ -522,6 +537,9 @@ static void mali_gp_bottom_half(void *data) mali_group_bottom_half(core->group, GROUP_EVENT_GP_JOB_TIMED_OUT); } core->core_timed_out = MALI_FALSE; +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } else if (irq_readout & MALIGP2_REG_VAL_IRQ_PLBU_OUT_OF_MEM) @@ -538,25 +556,30 @@ static void mali_gp_bottom_half(void *data) mali_gp_post_process_job(core, MALI_TRUE); MALI_DEBUG_PRINT(3, ("Mali GP: PLBU needs more heap memory\n")); mali_group_bottom_half(core->group, GROUP_EVENT_GP_OOM); /* Will release group lock */ +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } else if (irq_readout & MALIGP2_REG_VAL_IRQ_HANG) { - /* Just ignore hang interrupts, the job timer will detect hanging jobs anyways */ - mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_CLEAR, MALIGP2_REG_VAL_IRQ_HANG); + /* we mask hang interrupts, so this should never happen... */ + MALI_DEBUG_ASSERT( 0 ); } - /* - * The only way to get here is if we got a HANG interrupt, which we ignore, or only one of two needed END_CMD_LST interrupts. - * Re-enable interrupts and let core continue to run. - */ - mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_MASK, MALIGP2_REG_VAL_IRQ_MASK_USED); + /* The only way to get here is if we only got one of two needed END_CMD_LST + * interrupts. Disable the interrupt that has been received and continue to + * run. */ + mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_MASK, + MALIGP2_REG_VAL_IRQ_MASK_USED & + ((irq_readout & MALIGP2_REG_VAL_IRQ_PLBU_END_CMD_LST) + ? ~MALIGP2_REG_VAL_IRQ_PLBU_END_CMD_LST + : ~MALIGP2_REG_VAL_IRQ_VS_END_CMD_LST + )); mali_group_unlock(core->group); #if MALI_TIMELINE_PROFILING_ENABLED -#if 0 /* Bottom half TLP logging is currently not supported */ - _mali_osk_profiling_add_event( MALI_PROFILING_EVENT_TYPE_STOP| MALI_PROFILING_EVENT_CHANNEL_SOFTWARE , _mali_osk_get_pid(), _mali_osk_get_tid()+11000, 0, 0, 0); -#endif + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); #endif } @@ -599,6 +622,51 @@ static void mali_gp_post_process_job(struct mali_gp_core *core, mali_bool suspen u32 event_id; #endif +#if PROFILING_PRINT_L2_HITRATE_ON_GP_FINISH + { + u32 src0, value0, src1, value1, sum, per_thousand, per_thousand_now, diff0, diff1; + static u32 print_nr=0; + static u32 prev0=0; + static u32 prev1=0; + if ( !(++print_nr&511) ) + { + mali_l2_cache_core_get_counter_values(mali_l2_cache_core_get_glob_l2_core(0), &src0, &value0, &src1, &value1); + MALI_DEBUG_ASSERT( src0==20 ); /* Read hits */ + MALI_DEBUG_ASSERT( src1==21 ); /* Read misses */ + + sum = value0+value1; + if ( sum > 1000000 ) + { + per_thousand = value0 / (sum/1000); + } + else + { + per_thousand = (value0*1000) / (sum); + } + diff0 = value0-prev0; + diff1 = value1-prev1; + + sum = diff0 + diff1 ; + if ( sum > 1000000 ) + { + per_thousand_now = diff0 / (sum/1000); + } + else + { + per_thousand_now = (diff0*1000) / (sum); + } + + prev0=value0; + prev1=value1; + if (per_thousand_now<=1000) + { + MALI_DEBUG_PRINT(2, ("Mali L2: Read hits/misses: %d/%d = %d thousand_parts total, since previous: %d\n", value0, value1, per_thousand, per_thousand_now)); + } + + } + } +#endif + if (MALI_HW_CORE_NO_COUNTER != core->counter_src0_used) { val0 = mali_hw_core_register_read(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PERF_CNT_0_VALUE); diff --git a/drivers/media/video/samsung/mali/common/mali_gp.h b/drivers/media/video/samsung/mali/common/mali_gp.h index 3175b75..3175b75 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_gp.h +++ b/drivers/media/video/samsung/mali/common/mali_gp.h diff --git a/drivers/media/video/samsung/mali/common/mali_gp_job.c b/drivers/media/video/samsung/mali/common/mali_gp_job.c index abe1d93..2e445d6 100644 --- a/drivers/media/video/samsung/mali/common/mali_gp_job.c +++ b/drivers/media/video/samsung/mali/common/mali_gp_job.c @@ -13,29 +13,27 @@ #include "mali_osk_list.h" #include "mali_uk_types.h" -struct mali_gp_job *mali_gp_job_create(struct mali_session_data *session, _mali_uk_gp_start_job_s *args, u32 id) +struct mali_gp_job *mali_gp_job_create(struct mali_session_data *session, _mali_uk_gp_start_job_s *uargs, u32 id) { struct mali_gp_job *job; job = _mali_osk_malloc(sizeof(struct mali_gp_job)); if (NULL != job) { + if (0 != copy_from_user(&job->uargs, uargs, sizeof(_mali_uk_gp_start_job_s))) + { + _mali_osk_free(job); + return NULL; + } + _mali_osk_list_init(&job->list); job->session = session; job->id = id; - job->user_id = args->user_job_ptr; - _mali_osk_memcpy(job->frame_registers, args->frame_registers, sizeof(job->frame_registers)); - job->heap_current_addr = args->frame_registers[4]; - job->perf_counter_flag = args->perf_counter_flag; - job->perf_counter_src0 = args->perf_counter_src0; - job->perf_counter_src1 = args->perf_counter_src1; + job->heap_current_addr = job->uargs.frame_registers[4]; job->perf_counter_value0 = 0; job->perf_counter_value1 = 0; - job->pid = _mali_osk_get_pid(); job->tid = _mali_osk_get_tid(); - job->frame_builder_id = args->frame_builder_id; - job->flush_id = args->flush_id; return job; } diff --git a/drivers/media/video/samsung/mali/common/mali_gp_job.h b/drivers/media/video/samsung/mali/common/mali_gp_job.h index 9c29f1c..7b45552 100644 --- a/drivers/media/video/samsung/mali/common/mali_gp_job.h +++ b/drivers/media/video/samsung/mali/common/mali_gp_job.h @@ -25,22 +25,16 @@ struct mali_gp_job { _mali_osk_list_t list; /**< Used to link jobs together in the scheduler queue */ struct mali_session_data *session; /**< Session which submitted this job */ + _mali_uk_gp_start_job_s uargs; /**< Arguments from user space */ u32 id; /**< identifier for this job in kernel space (sequential numbering) */ - u32 user_id; /**< identifier for the job in user space */ - u32 frame_registers[MALIGP2_NUM_REGS_FRAME]; /**< core specific registers associated with this job, see ARM DDI0415A */ u32 heap_current_addr; /**< Holds the current HEAP address when the job has completed */ - u32 perf_counter_flag; /**< bitmask indicating which performance counters to enable, see \ref _MALI_PERFORMANCE_COUNTER_FLAG_SRC0_ENABLE and related macro definitions */ - u32 perf_counter_src0; /**< source id for performance counter 0 (see ARM DDI0415A, Table 3-60) */ - u32 perf_counter_src1; /**< source id for performance counter 1 (see ARM DDI0415A, Table 3-60) */ u32 perf_counter_value0; /**< Value of performance counter 0 (to be returned to user space) */ u32 perf_counter_value1; /**< Value of performance counter 1 (to be returned to user space) */ u32 pid; /**< Process ID of submitting process */ u32 tid; /**< Thread ID of submitting thread */ - u32 frame_builder_id; /**< id of the originating frame builder */ - u32 flush_id; /**< flush id within the originating frame builder */ }; -struct mali_gp_job *mali_gp_job_create(struct mali_session_data *session, _mali_uk_gp_start_job_s *args, u32 id); +struct mali_gp_job *mali_gp_job_create(struct mali_session_data *session, _mali_uk_gp_start_job_s *uargs, u32 id); void mali_gp_job_delete(struct mali_gp_job *job); MALI_STATIC_INLINE u32 mali_gp_job_get_id(struct mali_gp_job *job) @@ -50,22 +44,32 @@ MALI_STATIC_INLINE u32 mali_gp_job_get_id(struct mali_gp_job *job) MALI_STATIC_INLINE u32 mali_gp_job_get_user_id(struct mali_gp_job *job) { - return job->user_id; + return job->uargs.user_job_ptr; } MALI_STATIC_INLINE u32 mali_gp_job_get_frame_builder_id(struct mali_gp_job *job) { - return job->frame_builder_id; + return job->uargs.frame_builder_id; } MALI_STATIC_INLINE u32 mali_gp_job_get_flush_id(struct mali_gp_job *job) { - return job->flush_id; + return job->uargs.flush_id; +} + +MALI_STATIC_INLINE u32 mali_gp_job_get_pid(struct mali_gp_job *job) +{ + return job->pid; +} + +MALI_STATIC_INLINE u32 mali_gp_job_get_tid(struct mali_gp_job *job) +{ + return job->tid; } MALI_STATIC_INLINE u32* mali_gp_job_get_frame_registers(struct mali_gp_job *job) { - return job->frame_registers; + return job->uargs.frame_registers; } MALI_STATIC_INLINE struct mali_session_data *mali_gp_job_get_session(struct mali_gp_job *job) @@ -75,12 +79,12 @@ MALI_STATIC_INLINE struct mali_session_data *mali_gp_job_get_session(struct mali MALI_STATIC_INLINE mali_bool mali_gp_job_has_vs_job(struct mali_gp_job *job) { - return (job->frame_registers[0] != job->frame_registers[1]) ? MALI_TRUE : MALI_FALSE; + return (job->uargs.frame_registers[0] != job->uargs.frame_registers[1]) ? MALI_TRUE : MALI_FALSE; } MALI_STATIC_INLINE mali_bool mali_gp_job_has_plbu_job(struct mali_gp_job *job) { - return (job->frame_registers[2] != job->frame_registers[3]) ? MALI_TRUE : MALI_FALSE; + return (job->uargs.frame_registers[2] != job->uargs.frame_registers[3]) ? MALI_TRUE : MALI_FALSE; } MALI_STATIC_INLINE u32 mali_gp_job_get_current_heap_addr(struct mali_gp_job *job) @@ -95,17 +99,17 @@ MALI_STATIC_INLINE void mali_gp_job_set_current_heap_addr(struct mali_gp_job *jo MALI_STATIC_INLINE u32 mali_gp_job_get_perf_counter_flag(struct mali_gp_job *job) { - return job->perf_counter_flag; + return job->uargs.perf_counter_flag; } MALI_STATIC_INLINE u32 mali_gp_job_get_perf_counter_src0(struct mali_gp_job *job) { - return job->perf_counter_src0; + return job->uargs.perf_counter_src0; } MALI_STATIC_INLINE u32 mali_gp_job_get_perf_counter_src1(struct mali_gp_job *job) { - return job->perf_counter_src1; + return job->uargs.perf_counter_src1; } MALI_STATIC_INLINE u32 mali_gp_job_get_perf_counter_value0(struct mali_gp_job *job) diff --git a/drivers/media/video/samsung/mali/common/mali_gp_scheduler.c b/drivers/media/video/samsung/mali/common/mali_gp_scheduler.c index 05f00fc..52fa15b 100644 --- a/drivers/media/video/samsung/mali/common/mali_gp_scheduler.c +++ b/drivers/media/video/samsung/mali/common/mali_gp_scheduler.c @@ -56,13 +56,12 @@ _mali_osk_errcode_t mali_gp_scheduler_initialize(void) _MALI_OSK_INIT_LIST_HEAD(&job_queue); gp_scheduler_lock = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_SCHEDULER); - gp_scheduler_working_wait_queue = _mali_osk_wait_queue_init(); - if (NULL == gp_scheduler_lock) { return _MALI_OSK_ERR_NOMEM; } + gp_scheduler_working_wait_queue = _mali_osk_wait_queue_init(); if (NULL == gp_scheduler_working_wait_queue) { _mali_osk_lock_term(gp_scheduler_lock); @@ -275,30 +274,28 @@ void mali_gp_scheduler_resume(void) mali_gp_scheduler_unlock(); } -_mali_osk_errcode_t _mali_ukk_gp_start_job(_mali_uk_gp_start_job_s *args) +_mali_osk_errcode_t _mali_ukk_gp_start_job(void *ctx, _mali_uk_gp_start_job_s *uargs) { struct mali_session_data *session; struct mali_gp_job *job; - MALI_DEBUG_ASSERT_POINTER(args); + MALI_DEBUG_ASSERT_POINTER(uargs); + MALI_DEBUG_ASSERT_POINTER(ctx); - if (NULL == args->ctx) - { - return _MALI_OSK_ERR_INVALID_ARGS; - } + session = (struct mali_session_data*)ctx; - session = (struct mali_session_data*)args->ctx; - if (NULL == session) - { - return _MALI_OSK_ERR_FAULT; - } - - job = mali_gp_job_create(session, args, mali_scheduler_get_new_id()); + job = mali_gp_job_create(session, uargs, mali_scheduler_get_new_id()); if (NULL == job) { return _MALI_OSK_ERR_NOMEM; } +#if PROFILING_SKIP_PP_AND_GP_JOBS +#warning GP jobs will not be executed + mali_gp_scheduler_return_job_to_user(job, MALI_TRUE); + return _MALI_OSK_ERR_OK; +#endif + mali_gp_scheduler_lock(); _mali_osk_list_addtail(&job->list, &job_queue); diff --git a/drivers/media/video/samsung/mali/common/mali_gp_scheduler.h b/drivers/media/video/samsung/mali/common/mali_gp_scheduler.h index ef58509..ef58509 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_gp_scheduler.h +++ b/drivers/media/video/samsung/mali/common/mali_gp_scheduler.h diff --git a/drivers/media/video/samsung/mali/common/mali_group.c b/drivers/media/video/samsung/mali/common/mali_group.c index 9202bc1..94bf774 100644 --- a/drivers/media/video/samsung/mali/common/mali_group.c +++ b/drivers/media/video/samsung/mali/common/mali_group.c @@ -536,7 +536,7 @@ static enum mali_group_activate_pd_status mali_group_activate_page_directory(str activate_success = mali_mmu_activate_page_directory(group->mmu, mali_session_get_page_directory(session)); MALI_DEBUG_ASSERT(activate_success); - if ( MALI_FALSE== activate_success ) return MALI_FALSE; + if ( MALI_FALSE== activate_success ) return MALI_GROUP_ACTIVATE_PD_STATUS_FAILED; group->session = session; retval = MALI_GROUP_ACTIVATE_PD_STATUS_OK_SWITCHED_PD; } diff --git a/drivers/media/video/samsung/mali/common/mali_group.h b/drivers/media/video/samsung/mali/common/mali_group.h index 3533d13..1561d6b 100644 --- a/drivers/media/video/samsung/mali/common/mali_group.h +++ b/drivers/media/video/samsung/mali/common/mali_group.h @@ -102,7 +102,7 @@ _mali_osk_errcode_t mali_group_start_gp_job(struct mali_group *group, struct mal */ _mali_osk_errcode_t mali_group_start_pp_job(struct mali_group *group, struct mali_pp_job *job, u32 sub_job); -/** @brief Resume GP job that suspended waiting for more heap memory +/** @brief Resume GP job that suspended waiting for more heap memory */ void mali_group_resume_gp_with_new_heap(struct mali_group *group, u32 job_id, u32 start_addr, u32 end_addr); /** @brief Abort GP job diff --git a/drivers/media/video/samsung/mali/common/mali_hw_core.c b/drivers/media/video/samsung/mali/common/mali_hw_core.c index 0b08622..0b08622 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_hw_core.c +++ b/drivers/media/video/samsung/mali/common/mali_hw_core.c diff --git a/drivers/media/video/samsung/mali/common/mali_hw_core.h b/drivers/media/video/samsung/mali/common/mali_hw_core.h index c797804..b62e843 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_hw_core.h +++ b/drivers/media/video/samsung/mali/common/mali_hw_core.h @@ -48,6 +48,20 @@ MALI_STATIC_INLINE void mali_hw_core_register_write_relaxed(struct mali_hw_core _mali_osk_mem_iowrite32_relaxed(core->mapped_registers, relative_address, new_val); } +/* Conditionally write a register. + * The register will only be written if the new value is different from the old_value. + * If the new value is different, the old value will also be updated */ +MALI_STATIC_INLINE void mali_hw_core_register_write_relaxed_conditional(struct mali_hw_core *core, u32 relative_address, u32 new_val, const u32 old_val) +{ + MALI_DEBUG_PRINT(6, ("register_write_relaxed for core %s, relative addr=0x%04X, val=0x%08X\n", + core->description, relative_address, new_val)); + if(old_val != new_val) + { + _mali_osk_mem_iowrite32_relaxed(core->mapped_registers, relative_address, new_val); + } +} + + MALI_STATIC_INLINE void mali_hw_core_register_write(struct mali_hw_core *core, u32 relative_address, u32 new_val) { MALI_DEBUG_PRINT(6, ("register_write for core %s, relative addr=0x%04X, val=0x%08X\n", @@ -68,4 +82,23 @@ MALI_STATIC_INLINE void mali_hw_core_register_write_array_relaxed(struct mali_hw } } +/* Conditionally write a set of registers. + * The register will only be written if the new value is different from the old_value. + * If the new value is different, the old value will also be updated */ +MALI_STATIC_INLINE void mali_hw_core_register_write_array_relaxed_conditional(struct mali_hw_core *core, u32 relative_address, u32 *write_array, u32 nr_of_regs, const u32* old_array) +{ + u32 i; + MALI_DEBUG_PRINT(6, ("register_write_array: for core %s, relative addr=0x%04X, nr of regs=%u\n", + core->description,relative_address, nr_of_regs)); + + /* Do not use burst writes against the registers */ + for (i = 0; i< nr_of_regs; i++) + { + if(old_array[i] != write_array[i]) + { + mali_hw_core_register_write_relaxed(core, relative_address + i*4, write_array[i]); + } + } +} + #endif /* __MALI_HW_CORE_H__ */ diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_common.h b/drivers/media/video/samsung/mali/common/mali_kernel_common.h index b354f92..a33660b 100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_common.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_common.h @@ -18,16 +18,6 @@ #endif #endif -/* Macro for generating a kernel panic. - * Turned on off by compile-time Makefile settings - */ -#if defined(USING_KERNEL_PANIC) -#include <linux/kernel.h> - #define MALI_PANIC(fmt, args...) panic( fmt, ## args ); -#else - #define MALI_PANIC(fmt, args...) -#endif - /* The file include several useful macros for error checking, debugging and printing. * - MALI_PRINTF(...) Do not use this function: Will be included in Release builds. * - MALI_DEBUG_PRINT(nr, (X) ) Prints the second argument if nr<=MALI_DEBUG_LEVEL. diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_core.c b/drivers/media/video/samsung/mali/common/mali_kernel_core.c index 0155dfc..f31c505 100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_core.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_core.c @@ -35,6 +35,10 @@ #if MALI_TIMELINE_PROFILING_ENABLED #include "mali_osk_profiling.h" #endif +#if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED +#include "mali_profiling_internal.h" +#endif + /** Pointer to table of resource definitions available to the Mali driver. * _mali_osk_resources_init() sets up the pointer to this table. @@ -52,21 +56,12 @@ static u32 global_gpu_base_address = 0; static u32 global_gpu_major_version = 0; static u32 global_gpu_minor_version = 0; -static _mali_osk_errcode_t build_system_info(void); -static void cleanup_system_info(_mali_system_info *cleanup); - -/* system info variables */ -static _mali_osk_lock_t *system_info_lock = NULL; -static _mali_system_info *system_info = NULL; -static u32 system_info_size = 0; static u32 first_pp_offset = 0; -#define HANG_CHECK_MSECS_DEFAULT 500 /* 500 ms */ #define WATCHDOG_MSECS_DEFAULT 4000 /* 4 s */ /* timer related */ int mali_max_job_runtime = WATCHDOG_MSECS_DEFAULT; -int mali_hang_check_interval = HANG_CHECK_MSECS_DEFAULT; static _mali_osk_resource_t *mali_find_resource(_mali_osk_resource_type_t type, u32 offset) { @@ -606,9 +601,6 @@ _mali_osk_errcode_t mali_initialize_subsystems(void) _mali_osk_errcode_t err; mali_bool is_pmu_enabled; - MALI_CHECK_NON_NULL(system_info_lock = _mali_osk_lock_init( (_mali_osk_lock_flags_t)(_MALI_OSK_LOCKFLAG_SPINLOCK - | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE), 0, 0 ), _MALI_OSK_ERR_FAULT); - err = mali_session_initialize(); if (_MALI_OSK_ERR_OK != err) goto session_init_failed; @@ -621,10 +613,6 @@ _mali_osk_errcode_t mali_initialize_subsystems(void) } #endif - /* Build dummy system info. Will be removed in the future. */ - err = build_system_info(); - if (_MALI_OSK_ERR_OK != err) goto build_system_info_failed; - /* Get data from config.h */ err = _mali_osk_resources_init(&arch_configuration, &num_resources); if (_MALI_OSK_ERR_OK != err) goto osk_resources_init_failed; @@ -729,8 +717,6 @@ parse_memory_config_failed: memory_init_failed: _mali_osk_resources_term(&arch_configuration, num_resources); osk_resources_init_failed: - cleanup_system_info(system_info); -build_system_info_failed: #if MALI_TIMELINE_PROFILING_ENABLED _mali_osk_profiling_term(); #endif @@ -742,6 +728,7 @@ session_init_failed: void mali_terminate_subsystems(void) { struct mali_pmu_core *pmu; + MALI_DEBUG_PRINT(2, ("terminate_subsystems() called\n")); /* shut down subsystems in reverse order from startup */ @@ -777,18 +764,11 @@ void mali_terminate_subsystems(void) _mali_osk_resources_term(&arch_configuration, num_resources); - cleanup_system_info(system_info); - #if MALI_TIMELINE_PROFILING_ENABLED _mali_osk_profiling_term(); #endif mali_session_terminate(); - - if (NULL != system_info_lock) - { - _mali_osk_lock_term( system_info_lock ); - } } _mali_product_id_t mali_kernel_core_get_product_id(void) @@ -809,94 +789,6 @@ void mali_kernel_core_wakeup(void) } } -static void cleanup_system_info(_mali_system_info *cleanup) -{ - _mali_core_info * current_core; - _mali_mem_info * current_mem; - - /* delete all the core info structs */ - while (NULL != cleanup->core_info) - { - current_core = cleanup->core_info; - cleanup->core_info = cleanup->core_info->next; - _mali_osk_free(current_core); - } - - /* delete all the mem info struct */ - while (NULL != cleanup->mem_info) - { - current_mem = cleanup->mem_info; - cleanup->mem_info = cleanup->mem_info->next; - _mali_osk_free(current_mem); - } - - /* delete the system info struct itself */ - _mali_osk_free(cleanup); -} - -/* Build a dummy system info struct. User space still need this. */ -static _mali_osk_errcode_t build_system_info(void) -{ - _mali_system_info * new_info; - _mali_core_info * current_core; - _mali_mem_info * current_mem; - u32 new_size = 0; - - /* create a new system info struct */ - MALI_CHECK_NON_NULL(new_info = (_mali_system_info *)_mali_osk_malloc(sizeof(_mali_system_info)), _MALI_OSK_ERR_NOMEM); - - _mali_osk_memset(new_info, 0, sizeof(_mali_system_info)); - - /* fill in the info */ - new_info->has_mmu = 1; - new_info->drivermode = _MALI_DRIVER_MODE_NORMAL; - - new_info->core_info = NULL; /* Not used by user space */ - - new_info->mem_info = _mali_osk_calloc(1, sizeof(_mali_mem_info)); - if(NULL == new_info->mem_info) - { - _mali_osk_free(new_info); - return _MALI_OSK_ERR_NOMEM; - } - - new_info->mem_info->size = 1024 * 1024 * 1024; /* 1GiB */ - new_info->mem_info->flags = _MALI_CPU_WRITEABLE | _MALI_CPU_READABLE | _MALI_PP_READABLE | _MALI_PP_WRITEABLE |_MALI_GP_READABLE | _MALI_GP_WRITEABLE | _MALI_MMU_READABLE | _MALI_MMU_WRITEABLE; - new_info->mem_info->maximum_order_supported = 30; - new_info->mem_info->identifier = 0; - new_info->mem_info->next = NULL; - - /* building succeeded, calculate the size */ - - /* size needed of the system info struct itself */ - new_size = sizeof(_mali_system_info); - - /* size needed for the cores */ - for (current_core = new_info->core_info; NULL != current_core; current_core = current_core->next) - { - new_size += sizeof(_mali_core_info); - } - - /* size needed for the memory banks */ - for (current_mem = new_info->mem_info; NULL != current_mem; current_mem = current_mem->next) - { - new_size += sizeof(_mali_mem_info); - } - - /* lock system info access so a user wont't get a corrupted version */ - _mali_osk_lock_wait( system_info_lock, _MALI_OSK_LOCKMODE_RW ); - - /* set new info */ - system_info = new_info; - system_info_size = new_size; - - /* we're safe */ - _mali_osk_lock_signal( system_info_lock, _MALI_OSK_LOCKMODE_RW ); - - /* ok result */ - return _MALI_OSK_ERR_OK; -} - _mali_osk_errcode_t _mali_ukk_get_api_version( _mali_uk_get_api_version_s *args ) { MALI_DEBUG_ASSERT_POINTER(args); @@ -918,102 +810,6 @@ _mali_osk_errcode_t _mali_ukk_get_api_version( _mali_uk_get_api_version_s *args MALI_SUCCESS; } -_mali_osk_errcode_t _mali_ukk_get_system_info_size(_mali_uk_get_system_info_size_s *args) -{ - MALI_DEBUG_ASSERT_POINTER(args); - args->size = system_info_size; - MALI_SUCCESS; -} - -_mali_osk_errcode_t _mali_ukk_get_system_info( _mali_uk_get_system_info_s *args ) -{ - _mali_core_info * current_core; - _mali_mem_info * current_mem; - _mali_osk_errcode_t err = _MALI_OSK_ERR_FAULT; - void * current_write_pos, ** current_patch_pos; - u32 adjust_ptr_base; - - /* check input */ - MALI_DEBUG_ASSERT_POINTER(args); - MALI_CHECK_NON_NULL(args->ctx, _MALI_OSK_ERR_INVALID_ARGS); - MALI_CHECK_NON_NULL(args->system_info, _MALI_OSK_ERR_INVALID_ARGS); - - /* lock the system info */ - _mali_osk_lock_wait( system_info_lock, _MALI_OSK_LOCKMODE_RW ); - - /* first check size */ - if (args->size < system_info_size) goto exit_when_locked; - - /* we build a copy of system_info in the user space buffer specified by the user and - * patch up the pointers. The ukk_private members of _mali_uk_get_system_info_s may - * indicate a different base address for patching the pointers (normally the - * address of the provided system_info buffer would be used). This is helpful when - * the system_info buffer needs to get copied to user space and the pointers need - * to be in user space. - */ - if (0 == args->ukk_private) - { - adjust_ptr_base = (u32)args->system_info; - } - else - { - adjust_ptr_base = args->ukk_private; - } - - /* copy each struct into the buffer, and update its pointers */ - current_write_pos = (void *)args->system_info; - - /* first, the master struct */ - _mali_osk_memcpy(current_write_pos, system_info, sizeof(_mali_system_info)); - - /* advance write pointer */ - current_write_pos = (void *)((u32)current_write_pos + sizeof(_mali_system_info)); - - /* first we write the core info structs, patch starts at master's core_info pointer */ - current_patch_pos = (void **)((u32)args->system_info + offsetof(_mali_system_info, core_info)); - - for (current_core = system_info->core_info; NULL != current_core; current_core = current_core->next) - { - - /* patch the pointer pointing to this core */ - *current_patch_pos = (void*)(adjust_ptr_base + ((u32)current_write_pos - (u32)args->system_info)); - - /* copy the core info */ - _mali_osk_memcpy(current_write_pos, current_core, sizeof(_mali_core_info)); - - /* update patch pos */ - current_patch_pos = (void **)((u32)current_write_pos + offsetof(_mali_core_info, next)); - - /* advance write pos in memory */ - current_write_pos = (void *)((u32)current_write_pos + sizeof(_mali_core_info)); - } - /* patching of last patch pos is not needed, since we wrote NULL there in the first place */ - - /* then we write the mem info structs, patch starts at master's mem_info pointer */ - current_patch_pos = (void **)((u32)args->system_info + offsetof(_mali_system_info, mem_info)); - - for (current_mem = system_info->mem_info; NULL != current_mem; current_mem = current_mem->next) - { - /* patch the pointer pointing to this core */ - *current_patch_pos = (void*)(adjust_ptr_base + ((u32)current_write_pos - (u32)args->system_info)); - - /* copy the core info */ - _mali_osk_memcpy(current_write_pos, current_mem, sizeof(_mali_mem_info)); - - /* update patch pos */ - current_patch_pos = (void **)((u32)current_write_pos + offsetof(_mali_mem_info, next)); - - /* advance write pos in memory */ - current_write_pos = (void *)((u32)current_write_pos + sizeof(_mali_mem_info)); - } - /* patching of last patch pos is not needed, since we wrote NULL there in the first place */ - - err = _MALI_OSK_ERR_OK; -exit_when_locked: - _mali_osk_lock_signal( system_info_lock, _MALI_OSK_LOCKMODE_RW ); - MALI_ERROR(err); -} - _mali_osk_errcode_t _mali_ukk_wait_for_notification( _mali_uk_wait_for_notification_s *args ) { _mali_osk_errcode_t err; @@ -1117,7 +913,7 @@ _mali_osk_errcode_t _mali_ukk_open(void **context) if (0 != mali_dlbu_phys_addr) { - mali_mmu_pagedir_update(session_data->page_directory, MALI_DLB_VIRT_ADDR, mali_dlbu_phys_addr, _MALI_OSK_MALI_PAGE_SIZE); + mali_mmu_pagedir_update(session_data->page_directory, MALI_DLB_VIRT_ADDR, mali_dlbu_phys_addr, _MALI_OSK_MALI_PAGE_SIZE, MALI_CACHE_STANDARD); } if (_MALI_OSK_ERR_OK != mali_memory_session_begin(session_data)) diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_core.h b/drivers/media/video/samsung/mali/common/mali_kernel_core.h index d424c48..0ac967e 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_core.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_core.h @@ -13,7 +13,6 @@ #include "mali_osk.h" -extern int mali_hang_check_interval; extern int mali_max_job_runtime; typedef enum diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.c b/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.c index b9f05ca..b9f05ca 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.c diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.h b/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.h index 82ed94d..82ed94d 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_descriptor_mapping.h diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.c b/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.c index 7462a6d..2830ff8 100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.c @@ -95,7 +95,7 @@ static u32 os_allocator_stat(mali_physical_memory_allocator * allocator) static void os_allocator_destroy(mali_physical_memory_allocator * allocator) { os_allocator * info; - MALI_DEBUG_ASSERT_POINTER(allocator); + MALI_DEBUG_ASSERT_POINTER(allocator); MALI_DEBUG_ASSERT_POINTER(allocator->ctx); info = (os_allocator*)allocator->ctx; _mali_osk_lock_term(info->mutex); @@ -132,7 +132,7 @@ static mali_physical_memory_allocation_result os_allocator_allocate(void* ctx, m allocation->num_pages = ((left + _MALI_OSK_CPU_PAGE_SIZE - 1) & ~(_MALI_OSK_CPU_PAGE_SIZE - 1)) >> _MALI_OSK_CPU_PAGE_ORDER; MALI_DEBUG_PRINT(6, ("Allocating page array of size %d bytes\n", allocation->num_pages * sizeof(struct page*))); - while (left > 0) + while (left > 0 && ((info->num_pages_allocated + pages_allocated) < info->num_pages_max) && _mali_osk_mem_check_allocated(os_mem_max_usage)) { err = mali_allocation_engine_map_physical(engine, descriptor, *offset, MALI_MEMORY_ALLOCATION_OS_ALLOCATED_PHYSADDR_MAGIC, info->cpu_usage_adjust, _MALI_OSK_CPU_PAGE_SIZE); if ( _MALI_OSK_ERR_OK != err) @@ -243,7 +243,7 @@ static void os_allocator_release(void * ctx, void * handle) static mali_physical_memory_allocation_result os_allocator_allocate_page_table_block(void * ctx, mali_page_table_block * block) { - int allocation_order = 11; /* _MALI_OSK_CPU_PAGE_SIZE << 11 */ + int allocation_order = 6; /* _MALI_OSK_CPU_PAGE_SIZE << 6 */ void *virt = NULL; u32 size = _MALI_OSK_CPU_PAGE_SIZE << allocation_order; os_allocator * info; diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.h b/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.h index 0946169..59e6494 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010 ARM Limited. All rights reserved. + * Copyright (C) 2010, 2012 ARM Limited. All rights reserved. * * This program is free software and is provided to you under the terms of the GNU General Public License version 2 * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.c b/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.c index 1377560..d770e3e 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.c @@ -252,6 +252,7 @@ _mali_osk_errcode_t mali_allocation_engine_map_physical(mali_allocation_engine m if ( _MALI_OSK_ERR_OK != err ) { + MALI_DEBUG_PRINT(2, ("Map failed: %s %d\n", __FUNCTION__, __LINE__)); MALI_ERROR( err ); } } @@ -271,7 +272,7 @@ _mali_osk_errcode_t mali_allocation_engine_map_physical(mali_allocation_engine m MALI_DEBUG_PRINT( 2, ("Process address manager succeeded, but Mali Address manager failed for phys=0x%08X size=0x%08X, offset=0x%08X. Will unmap.\n", phys, size, offset)); engine->process_address->unmap_physical(descriptor, offset, size, unmap_flags); } - + MALI_DEBUG_PRINT(2, ("Map mali failed: %s %d\n", __FUNCTION__, __LINE__)); MALI_ERROR( err ); } diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.h b/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.h index cda74c3..3b41cee 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_memory_engine.h @@ -59,6 +59,7 @@ typedef struct mali_memory_allocation u32 size; /**< Size of the allocation */ u32 permission; /**< Permission settings */ mali_memory_allocation_flag flags; + u32 cache_settings; /* type: mali_memory_cache_settings, found in <linux/mali/mali_utgard_uk_types.h> Ump DD breaks if we include it...*/ _mali_osk_lock_t * lock; diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_utilization.c b/drivers/media/video/samsung/mali/common/mali_kernel_utilization.c index a374dbf..a374dbf 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_utilization.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_utilization.c diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_utilization.h b/drivers/media/video/samsung/mali/common/mali_kernel_utilization.h index 1f60517..1f60517 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_utilization.h +++ b/drivers/media/video/samsung/mali/common/mali_kernel_utilization.h diff --git a/drivers/media/video/samsung/mali/common/mali_l2_cache.c b/drivers/media/video/samsung/mali/common/mali_l2_cache.c index aa5cc54..b7267f1 100644 --- a/drivers/media/video/samsung/mali/common/mali_l2_cache.c +++ b/drivers/media/video/samsung/mali/common/mali_l2_cache.c @@ -194,44 +194,60 @@ u32 mali_l2_cache_get_id(struct mali_l2_cache_core *cache) mali_bool mali_l2_cache_core_set_counter_src0(struct mali_l2_cache_core *cache, u32 counter) { u32 value = 0; /* disabled src */ + mali_bool core_is_on; MALI_DEBUG_ASSERT_POINTER(cache); - MALI_DEBUG_ASSERT(counter < (1 << 7)); /* the possible values are 0-127 */ + + core_is_on = mali_l2_cache_lock_power_state(cache); _mali_osk_lock_wait(cache->counter_lock, _MALI_OSK_LOCKMODE_RW); cache->counter_src0 = counter; - if (counter != MALI_HW_CORE_NO_COUNTER) + if (MALI_HW_CORE_NO_COUNTER != counter) { value = counter; } - mali_hw_core_register_write(&cache->hw_core, MALI400_L2_CACHE_REGISTER_PERFCNT_SRC0, value); + if (MALI_TRUE == core_is_on) + { + mali_hw_core_register_write(&cache->hw_core, MALI400_L2_CACHE_REGISTER_PERFCNT_SRC0, value); + } _mali_osk_lock_signal(cache->counter_lock, _MALI_OSK_LOCKMODE_RW); + + mali_l2_cache_unlock_power_state(cache); + return MALI_TRUE; } mali_bool mali_l2_cache_core_set_counter_src1(struct mali_l2_cache_core *cache, u32 counter) { u32 value = 0; /* disabled src */ + mali_bool core_is_on; MALI_DEBUG_ASSERT_POINTER(cache); - MALI_DEBUG_ASSERT(counter < (1 << 7)); /* the possible values are 0-127 */ + + core_is_on = mali_l2_cache_lock_power_state(cache); _mali_osk_lock_wait(cache->counter_lock, _MALI_OSK_LOCKMODE_RW); cache->counter_src1 = counter; - if (counter != MALI_HW_CORE_NO_COUNTER) + if (MALI_HW_CORE_NO_COUNTER != counter) { value = counter; } - mali_hw_core_register_write(&cache->hw_core, MALI400_L2_CACHE_REGISTER_PERFCNT_SRC1, value); + if (MALI_TRUE == core_is_on) + { + mali_hw_core_register_write(&cache->hw_core, MALI400_L2_CACHE_REGISTER_PERFCNT_SRC1, value); + } _mali_osk_lock_signal(cache->counter_lock, _MALI_OSK_LOCKMODE_RW); + + mali_l2_cache_unlock_power_state(cache); + return MALI_TRUE; } diff --git a/drivers/media/video/samsung/mali/common/mali_mem_validation.h b/drivers/media/video/samsung/mali/common/mali_mem_validation.h index 2043b44..2043b44 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_mem_validation.h +++ b/drivers/media/video/samsung/mali/common/mali_mem_validation.h diff --git a/drivers/media/video/samsung/mali/common/mali_memory.c b/drivers/media/video/samsung/mali/common/mali_memory.c index 7a11d1a..75506ed 100644 --- a/drivers/media/video/samsung/mali/common/mali_memory.c +++ b/drivers/media/video/samsung/mali/common/mali_memory.c @@ -146,6 +146,11 @@ static mali_physical_memory_allocator * physical_memory_allocators = NULL; static dedicated_memory_info * mem_region_registrations = NULL; +mali_allocation_engine mali_mem_get_memory_engine(void) +{ + return memory_engine; +} + /* called during module init */ _mali_osk_errcode_t mali_memory_initialize(void) { @@ -239,6 +244,8 @@ static void descriptor_table_cleanup_callback(int descriptor_id, void* map_targe void mali_memory_session_end(struct mali_session_data *session_data) { + _mali_osk_errcode_t err = _MALI_OSK_ERR_BUSY; + MALI_DEBUG_PRINT(3, ("MMU session end\n")); if (NULL == session_data) @@ -247,76 +254,63 @@ void mali_memory_session_end(struct mali_session_data *session_data) return; } -#ifndef MALI_UKK_HAS_IMPLICIT_MMAP_CLEANUP -#if _MALI_OSK_SPECIFIC_INDIRECT_MMAP -#error Indirect MMAP specified, but UKK does not have implicit MMAP cleanup. Current implementation does not handle this. -#else + while (err == _MALI_OSK_ERR_BUSY) { - _mali_osk_errcode_t err; - err = _MALI_OSK_ERR_BUSY; - while (err == _MALI_OSK_ERR_BUSY) - { - /* Lock the session so we can modify the memory list */ - _mali_osk_lock_wait( session_data->memory_lock, _MALI_OSK_LOCKMODE_RW ); - err = _MALI_OSK_ERR_OK; + /* Lock the session so we can modify the memory list */ + _mali_osk_lock_wait( session_data->memory_lock, _MALI_OSK_LOCKMODE_RW ); + err = _MALI_OSK_ERR_OK; - /* Free all memory engine allocations */ - if (0 == _mali_osk_list_empty(&session_data->memory_head)) - { - mali_memory_allocation *descriptor; - mali_memory_allocation *temp; - _mali_uk_mem_munmap_s unmap_args; + /* Free all memory engine allocations */ + if (0 == _mali_osk_list_empty(&session_data->memory_head)) + { + mali_memory_allocation *descriptor; + mali_memory_allocation *temp; + _mali_uk_mem_munmap_s unmap_args; - MALI_DEBUG_PRINT(1, ("Memory found on session usage list during session termination\n")); + MALI_DEBUG_PRINT(1, ("Memory found on session usage list during session termination\n")); - unmap_args.ctx = session_data; + unmap_args.ctx = session_data; - /* use the 'safe' list iterator, since freeing removes the active block from the list we're iterating */ - _MALI_OSK_LIST_FOREACHENTRY(descriptor, temp, &session_data->memory_head, mali_memory_allocation, list) + /* use the 'safe' list iterator, since freeing removes the active block from the list we're iterating */ + _MALI_OSK_LIST_FOREACHENTRY(descriptor, temp, &session_data->memory_head, mali_memory_allocation, list) + { + MALI_DEBUG_PRINT(4, ("Freeing block with mali address 0x%x size %d mapped in user space at 0x%x\n", + descriptor->mali_address, descriptor->size, descriptor->size, descriptor->mapping) + ); + /* ASSERT that the descriptor's lock references the correct thing */ + MALI_DEBUG_ASSERT( descriptor->lock == session_data->memory_lock ); + /* Therefore, we have already locked the descriptor */ + + unmap_args.size = descriptor->size; + unmap_args.mapping = descriptor->mapping; + unmap_args.cookie = (u32)descriptor; + + /* + * This removes the descriptor from the list, and frees the descriptor + * + * Does not handle the _MALI_OSK_SPECIFIC_INDIRECT_MMAP case, since + * the only OS we are aware of that requires indirect MMAP also has + * implicit mmap cleanup. + */ + err = _mali_ukk_mem_munmap_internal( &unmap_args ); + + if (err == _MALI_OSK_ERR_BUSY) { - MALI_DEBUG_PRINT(4, ("Freeing block with mali address 0x%x size %d mapped in user space at 0x%x\n", - descriptor->mali_address, descriptor->size, descriptor->size, descriptor->mapping) - ); - /* ASSERT that the descriptor's lock references the correct thing */ - MALI_DEBUG_ASSERT( descriptor->lock == session_data->memory_lock ); - /* Therefore, we have already locked the descriptor */ - - unmap_args.size = descriptor->size; - unmap_args.mapping = descriptor->mapping; - unmap_args.cookie = (u32)descriptor; - + _mali_osk_lock_signal( session_data->memory_lock, _MALI_OSK_LOCKMODE_RW ); /* - * This removes the descriptor from the list, and frees the descriptor - * - * Does not handle the _MALI_OSK_SPECIFIC_INDIRECT_MMAP case, since - * the only OS we are aware of that requires indirect MMAP also has - * implicit mmap cleanup. - */ - err = _mali_ukk_mem_munmap_internal( &unmap_args ); - - if (err == _MALI_OSK_ERR_BUSY) - { - _mali_osk_lock_signal( session_data->memory_lock, _MALI_OSK_LOCKMODE_RW ); - /* - * Reason for this; - * We where unable to stall the MMU, probably because we are in page fault handling. - * Sleep for a while with the session lock released, then try again. - * Abnormal termination of programs with running Mali jobs is a normal reason for this. - */ - _mali_osk_time_ubusydelay(10); - break; /* Will jump back into: "while (err == _MALI_OSK_ERR_BUSY)" */ - } + * Reason for this; + * We where unable to stall the MMU, probably because we are in page fault handling. + * Sleep for a while with the session lock released, then try again. + * Abnormal termination of programs with running Mali jobs is a normal reason for this. + */ + _mali_osk_time_ubusydelay(10); + break; /* Will jump back into: "while (err == _MALI_OSK_ERR_BUSY)" */ } } } - /* Assert that we really did free everything */ - MALI_DEBUG_ASSERT( _mali_osk_list_empty(&session_data->memory_head) ); } -#endif /* _MALI_OSK_SPECIFIC_INDIRECT_MMAP */ -#else - /* Lock the session so we can modify the memory list */ - _mali_osk_lock_wait( session_data->memory_lock, _MALI_OSK_LOCKMODE_RW ); -#endif /* MALI_UKK_HAS_IMPLICIT_MMAP_CLEANUP */ + /* Assert that we really did free everything */ + MALI_DEBUG_ASSERT( _mali_osk_list_empty(&session_data->memory_head) ); if (NULL != session_data->descriptor_mapping) { @@ -601,7 +595,9 @@ _mali_osk_errcode_t _mali_ukk_attach_ump_mem( _mali_uk_attach_ump_mem_s *args ) descriptor->mali_address = args->mali_address; descriptor->mali_addr_mapping_info = (void*)session_data; descriptor->process_addr_mapping_info = NULL; /* do not map to process address space */ + descriptor->cache_settings = (u32) MALI_CACHE_STANDARD; descriptor->lock = session_data->memory_lock; + if (args->flags & _MALI_MAP_EXTERNAL_MAP_GUARD_PAGE) { descriptor->flags = MALI_MEMORY_ALLOCATION_FLAG_MAP_GUARD_PAGE; @@ -812,6 +808,7 @@ _mali_osk_errcode_t _mali_ukk_map_external_mem( _mali_uk_map_external_mem_s *arg descriptor->mali_address = args->mali_address; descriptor->mali_addr_mapping_info = (void*)session_data; descriptor->process_addr_mapping_info = NULL; /* do not map to process address space */ + descriptor->cache_settings = (u32)MALI_CACHE_STANDARD; descriptor->lock = session_data->memory_lock; if (args->flags & _MALI_MAP_EXTERNAL_MAP_GUARD_PAGE) { @@ -947,7 +944,7 @@ static _mali_osk_errcode_t mali_address_manager_map(mali_memory_allocation * des MALI_DEBUG_PRINT(7, ("Mali map: mapping 0x%08X to Mali address 0x%08X length 0x%08X\n", *phys_addr, mali_address, size)); - mali_mmu_pagedir_update(session_data->page_directory, mali_address, *phys_addr, size); + mali_mmu_pagedir_update(session_data->page_directory, mali_address, *phys_addr, size, descriptor->cache_settings); MALI_SUCCESS; } @@ -976,6 +973,7 @@ _mali_osk_errcode_t _mali_ukk_mem_mmap( _mali_uk_mem_mmap_s *args ) descriptor->process_addr_mapping_info = args->ukk_private; /* save to be used during physical manager callback */ descriptor->flags = MALI_MEMORY_ALLOCATION_FLAG_MAP_INTO_USERSPACE; + descriptor->cache_settings = (u32) args->cache_settings ; descriptor->lock = session_data->memory_lock; _mali_osk_list_init( &descriptor->list ); diff --git a/drivers/media/video/samsung/mali/common/mali_memory.h b/drivers/media/video/samsung/mali/common/mali_memory.h index 53a994c..78e2945 100644 --- a/drivers/media/video/samsung/mali/common/mali_memory.h +++ b/drivers/media/video/samsung/mali/common/mali_memory.h @@ -77,4 +77,6 @@ _mali_osk_errcode_t mali_memory_core_resource_os_memory(_mali_osk_resource_t * r */ _mali_osk_errcode_t mali_memory_core_resource_dedicated_memory(_mali_osk_resource_t * resource); +mali_allocation_engine mali_mem_get_memory_engine(void); + #endif /* __MALI_MEMORY_H__ */ diff --git a/drivers/media/video/samsung/mali/common/mali_mmu_page_directory.c b/drivers/media/video/samsung/mali/common/mali_mmu_page_directory.c index 43a4cf4..cc91ae9 100644 --- a/drivers/media/video/samsung/mali/common/mali_mmu_page_directory.c +++ b/drivers/media/video/samsung/mali/common/mali_mmu_page_directory.c @@ -297,9 +297,25 @@ void mali_mmu_pagedir_free(struct mali_page_directory *pagedir) } -void mali_mmu_pagedir_update(struct mali_page_directory *pagedir, u32 mali_address, u32 phys_address, u32 size) +void mali_mmu_pagedir_update(struct mali_page_directory *pagedir, u32 mali_address, u32 phys_address, u32 size, mali_memory_cache_settings cache_settings) { u32 end_address = mali_address + size; + u32 permission_bits; + + switch ( cache_settings ) + { + case MALI_CACHE_GP_READ_ALLOCATE: + MALI_DEBUG_PRINT(3, ("Map L2 GP_Read_allocate\n")); + permission_bits = MALI_MMU_FLAGS_FORCE_GP_READ_ALLOCATE; + break; + + case MALI_CACHE_STANDARD: + MALI_DEBUG_PRINT(3, ("Map L2 Standard\n")); + /*falltrough */ + default: + if ( MALI_CACHE_STANDARD != cache_settings) MALI_PRINT_ERROR(("Wrong cache settings\n")); + permission_bits = MALI_MMU_FLAGS_WRITE_PERMISSION | MALI_MMU_FLAGS_READ_PERMISSION | MALI_MMU_FLAGS_PRESENT; + } /* Map physical pages into MMU page tables */ for ( ; mali_address < end_address; mali_address += MALI_MMU_PAGE_SIZE, phys_address += MALI_MMU_PAGE_SIZE) @@ -307,7 +323,7 @@ void mali_mmu_pagedir_update(struct mali_page_directory *pagedir, u32 mali_addre MALI_DEBUG_ASSERT_POINTER(pagedir->page_entries_mapped[MALI_MMU_PDE_ENTRY(mali_address)]); _mali_osk_mem_iowrite32_relaxed(pagedir->page_entries_mapped[MALI_MMU_PDE_ENTRY(mali_address)], MALI_MMU_PTE_ENTRY(mali_address) * sizeof(u32), - phys_address | MALI_MMU_FLAGS_WRITE_PERMISSION | MALI_MMU_FLAGS_READ_PERMISSION | MALI_MMU_FLAGS_PRESENT); + phys_address | permission_bits); } _mali_osk_write_mem_barrier(); } diff --git a/drivers/media/video/samsung/mali/common/mali_mmu_page_directory.h b/drivers/media/video/samsung/mali/common/mali_mmu_page_directory.h index 8aababe..628833a 100644 --- a/drivers/media/video/samsung/mali/common/mali_mmu_page_directory.h +++ b/drivers/media/video/samsung/mali/common/mali_mmu_page_directory.h @@ -50,10 +50,27 @@ typedef enum mali_mmu_entry_flags MALI_MMU_FLAGS_PRESENT = 0x01, MALI_MMU_FLAGS_READ_PERMISSION = 0x02, MALI_MMU_FLAGS_WRITE_PERMISSION = 0x04, - MALI_MMU_FLAGS_MASK = 0x07 + MALI_MMU_FLAGS_OVERRIDE_CACHE = 0x8, + MALI_MMU_FLAGS_WRITE_CACHEABLE = 0x10, + MALI_MMU_FLAGS_WRITE_ALLOCATE = 0x20, + MALI_MMU_FLAGS_WRITE_BUFFERABLE = 0x40, + MALI_MMU_FLAGS_READ_CACHEABLE = 0x80, + MALI_MMU_FLAGS_READ_ALLOCATE = 0x100, + MALI_MMU_FLAGS_MASK = 0x1FF, } mali_mmu_entry_flags; +#define MALI_MMU_FLAGS_FORCE_GP_READ_ALLOCATE ( \ +MALI_MMU_FLAGS_PRESENT | \ + MALI_MMU_FLAGS_READ_PERMISSION | \ + MALI_MMU_FLAGS_WRITE_PERMISSION | \ + MALI_MMU_FLAGS_OVERRIDE_CACHE | \ + MALI_MMU_FLAGS_WRITE_CACHEABLE | \ + MALI_MMU_FLAGS_WRITE_BUFFERABLE | \ + MALI_MMU_FLAGS_READ_CACHEABLE | \ + MALI_MMU_FLAGS_READ_ALLOCATE ) + + struct mali_page_directory { u32 page_directory; /**< Physical address of the memory session's page directory */ @@ -68,7 +85,7 @@ _mali_osk_errcode_t mali_mmu_pagedir_map(struct mali_page_directory *pagedir, u3 _mali_osk_errcode_t mali_mmu_pagedir_unmap(struct mali_page_directory *pagedir, u32 mali_address, u32 size); /* Back virtual address space with actual pages. Assumes input is contiguous and 4k aligned. */ -void mali_mmu_pagedir_update(struct mali_page_directory *pagedir, u32 mali_address, u32 phys_address, u32 size); +void mali_mmu_pagedir_update(struct mali_page_directory *pagedir, u32 mali_address, u32 phys_address, u32 size, u32 cache_settings); u32 mali_page_directory_get_phys_address(struct mali_page_directory *pagedir, u32 index); diff --git a/drivers/media/video/samsung/mali/common/mali_osk.h b/drivers/media/video/samsung/mali/common/mali_osk.h index e32d15d..c478057 100644 --- a/drivers/media/video/samsung/mali/common/mali_osk.h +++ b/drivers/media/video/samsung/mali/common/mali_osk.h @@ -1422,17 +1422,6 @@ void _mali_osk_notification_queue_term( _mali_osk_notification_queue_t *queue ); */ void _mali_osk_notification_queue_send( _mali_osk_notification_queue_t *queue, _mali_osk_notification_t *object ); -#if MALI_STATE_TRACKING -/** @brief Receive a notification from a queue - * - * Check if a notification queue is empty. - * - * @param queue The queue to check. - * @return MALI_TRUE if queue is empty, otherwise MALI_FALSE. - */ -mali_bool _mali_osk_notification_queue_is_empty( _mali_osk_notification_queue_t *queue ); -#endif - /** @brief Receive a notification from a queue * * Receives a single notification from the given queue. diff --git a/drivers/media/video/samsung/mali/common/mali_osk_bitops.h b/drivers/media/video/samsung/mali/common/mali_osk_bitops.h index f262f7d..ada1488 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_osk_bitops.h +++ b/drivers/media/video/samsung/mali/common/mali_osk_bitops.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010 ARM Limited. All rights reserved. + * Copyright (C) 2010, 2012 ARM Limited. All rights reserved. * * This program is free software and is provided to you under the terms of the GNU General Public License version 2 * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. diff --git a/drivers/media/video/samsung/mali/common/mali_osk_list.h b/drivers/media/video/samsung/mali/common/mali_osk_list.h index a8d15f2..5987b0a 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_osk_list.h +++ b/drivers/media/video/samsung/mali/common/mali_osk_list.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010-2011 ARM Limited. All rights reserved. + * Copyright (C) 2010-2012 ARM Limited. All rights reserved. * * This program is free software and is provided to you under the terms of the GNU General Public License version 2 * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. diff --git a/drivers/media/video/samsung/mali/common/mali_osk_mali.h b/drivers/media/video/samsung/mali/common/mali_osk_mali.h index 427fcc8..427fcc8 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_osk_mali.h +++ b/drivers/media/video/samsung/mali/common/mali_osk_mali.h diff --git a/drivers/media/video/samsung/mali/common/mali_osk_profiling.h b/drivers/media/video/samsung/mali/common/mali_osk_profiling.h index fd9a8fb..bf1cf8c 100644 --- a/drivers/media/video/samsung/mali/common/mali_osk_profiling.h +++ b/drivers/media/video/samsung/mali/common/mali_osk_profiling.h @@ -11,12 +11,9 @@ #ifndef __MALI_OSK_PROFILING_H__ #define __MALI_OSK_PROFILING_H__ -#if MALI_TIMELINE_PROFILING_ENABLED +#if MALI_TIMELINE_PROFILING_ENABLED && defined (CONFIG_TRACEPOINTS) -#if defined (CONFIG_TRACEPOINTS) && !MALI_INTERNAL_TIMELINE_PROFILING_ENABLED #include "mali_linux_trace.h" -#endif /* CONFIG_TRACEPOINTS && !MALI_INTERNAL_TIMELINE_PROFILING_ENABLED */ - #include "mali_profiling_events.h" #define MALI_PROFILING_MAX_BUFFER_ENTRIES 1048576 @@ -59,13 +56,8 @@ _mali_osk_errcode_t _mali_osk_profiling_start(u32 * limit); * @param data4 Fifth data parameter, depending on event_id specified. * @return _MALI_OSK_ERR_OK on success, otherwise failure. */ -#if defined (CONFIG_TRACEPOINTS) && !MALI_INTERNAL_TIMELINE_PROFILING_ENABLED /* Call Linux tracepoint directly */ #define _mali_osk_profiling_add_event(event_id, data0, data1, data2, data3, data4) trace_mali_timeline_event((event_id), (data0), (data1), (data2), (data3), (data4)) -#else -/* Internal profiling is handled like a plain function call */ -void _mali_osk_profiling_add_event(u32 event_id, u32 data0, u32 data1, u32 data2, u32 data3, u32 data4); -#endif /** * Report a hardware counter event. @@ -74,13 +66,8 @@ void _mali_osk_profiling_add_event(u32 event_id, u32 data0, u32 data1, u32 data2 * @param value The value of the counter. */ -#if defined (CONFIG_TRACEPOINTS) && !MALI_INTERNAL_TIMELINE_PROFILING_ENABLED /* Call Linux tracepoint directly */ #define _mali_osk_profiling_report_hw_counter(counter_id, value) trace_mali_hw_counter(counter_id, value) -#else -/* Internal profiling is handled like a plain function call */ -void _mali_osk_profiling_report_hw_counter(u32 counter_id, u32 value); -#endif /** * Report SW counters @@ -140,7 +127,12 @@ mali_bool _mali_osk_profiling_have_recording(void); /** @} */ /* end group _mali_osk_profiling */ -#endif /* MALI_TIMELINE_PROFILING_ENABLED */ +#else + /* Dummy add_event, for when profiling is disabled. */ + +#define _mali_osk_profiling_add_event(event_id, data0, data1, data2, data3, data4) + +#endif /* MALI_TIMELINE_PROFILING_ENABLED && defined(CONFIG_TRACEPOINTS*/ #endif /* __MALI_OSK_PROFILING_H__ */ diff --git a/drivers/media/video/samsung/mali/common/mali_pm.c b/drivers/media/video/samsung/mali/common/mali_pm.c index 1ef3807..933e54e 100644 --- a/drivers/media/video/samsung/mali/common/mali_pm.c +++ b/drivers/media/video/samsung/mali/common/mali_pm.c @@ -150,16 +150,13 @@ inline void mali_pm_execute_state_change_unlock(void) static void mali_pm_powerup(void) { +#if !MALI_PMM_RUNTIME_JOB_CONTROL_ON MALI_DEBUG_PRINT(3, ("Mali PM: Setting GPU power mode to MALI_POWER_MODE_ON\n")); mali_platform_power_mode_change(MALI_POWER_MODE_ON); - -#if MALI_PMM_RUNTIME_JOB_CONTROL_ON - +#else /* Aquire our reference */ - MALI_DEBUG_PRINT(4, ("Mali PM: Getting device PM reference (=> requesting MALI_POWER_MODE_ON)\n")); _mali_osk_pm_dev_activate(); #endif - mali_group_power_on(); } @@ -169,10 +166,16 @@ static void mali_pm_powerdown(mali_power_mode power_mode) { mali_group_power_off(); } - mali_platform_power_mode_change(power_mode); -#if MALI_PMM_RUNTIME_JOB_CONTROL_ON +#if !MALI_PMM_RUNTIME_JOB_CONTROL_ON + mali_platform_power_mode_change(power_mode); +#else _mali_osk_pm_dev_idle(); + + if (MALI_POWER_MODE_DEEP_SLEEP == power_mode) + { + mali_platform_power_mode_change(power_mode); + } #endif } @@ -539,9 +542,11 @@ void mali_pm_os_resume(void) void mali_pm_runtime_suspend(void) { MALI_DEBUG_PRINT(2, ("Mali PM: OS runtime suspended\n")); + mali_platform_power_mode_change(MALI_POWER_MODE_LIGHT_SLEEP); } void mali_pm_runtime_resume(void) { - MALI_DEBUG_PRINT(3, ("Mali PM: OS runtime resumed\n")); + MALI_DEBUG_PRINT(2, ("Mali PM: OS runtime resumed\n")); + mali_platform_power_mode_change(MALI_POWER_MODE_ON); } diff --git a/drivers/media/video/samsung/mali/common/mali_pm.h b/drivers/media/video/samsung/mali/common/mali_pm.h index d4ccfde..d4ccfde 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_pm.h +++ b/drivers/media/video/samsung/mali/common/mali_pm.h diff --git a/drivers/media/video/samsung/mali/common/mali_pp.c b/drivers/media/video/samsung/mali/common/mali_pp.c index 5549f82..b525063 100644 --- a/drivers/media/video/samsung/mali/common/mali_pp.c +++ b/drivers/media/video/samsung/mali/common/mali_pp.c @@ -12,6 +12,7 @@ #include "mali_hw_core.h" #include "mali_group.h" #include "mali_osk.h" +#include "mali_pp_scheduler.h" #include "regs/mali_200_regs.h" #include "mali_kernel_common.h" #include "mali_kernel_core.h" @@ -194,6 +195,55 @@ _mali_osk_errcode_t mali_pp_stop_bus_wait(struct mali_pp_core *core) return _MALI_OSK_ERR_OK; } +/* Frame register reset values. + * Taken from the Mali400 TRM, 3.6. Pixel processor control register summary */ +static const u32 mali_frame_registers_reset_values[_MALI_PP_MAX_FRAME_REGISTERS] = +{ + 0x0, /* Renderer List Address Register */ + 0x0, /* Renderer State Word Base Address Register */ + 0x0, /* Renderer Vertex Base Register */ + 0x2, /* Feature Enable Register */ + 0x0, /* Z Clear Value Register */ + 0x0, /* Stencil Clear Value Register */ + 0x0, /* ABGR Clear Value 0 Register */ + 0x0, /* ABGR Clear Value 1 Register */ + 0x0, /* ABGR Clear Value 2 Register */ + 0x0, /* ABGR Clear Value 3 Register */ + 0x0, /* Bounding Box Left Right Register */ + 0x0, /* Bounding Box Bottom Register */ + 0x0, /* FS Stack Address Register */ + 0x0, /* FS Stack Size and Initial Value Register */ + 0x0, /* Reserved */ + 0x0, /* Reserved */ + 0x0, /* Origin Offset X Register */ + 0x0, /* Origin Offset Y Register */ + 0x75, /* Subpixel Specifier Register */ + 0x0, /* Tiebreak mode Register */ + 0x0, /* Polygon List Format Register */ + 0x0, /* Scaling Register */ + 0x0 /* Tilebuffer configuration Register */ +}; + +/* WBx register reset values */ +static const u32 mali_wb_registers_reset_values[_MALI_PP_MAX_WB_REGISTERS] = +{ + 0x0, /* WBx Source Select Register */ + 0x0, /* WBx Target Address Register */ + 0x0, /* WBx Target Pixel Format Register */ + 0x0, /* WBx Target AA Format Register */ + 0x0, /* WBx Target Layout */ + 0x0, /* WBx Target Scanline Length */ + 0x0, /* WBx Target Flags Register */ + 0x0, /* WBx MRT Enable Register */ + 0x0, /* WBx MRT Offset Register */ + 0x0, /* WBx Global Test Enable Register */ + 0x0, /* WBx Global Test Reference Value Register */ + 0x0 /* WBx Global Test Compare Function Register */ +}; + +/* Performance Counter 0 Enable Register reset value */ +static const u32 mali_perf_cnt_enable_reset_value = 0; + _mali_osk_errcode_t mali_pp_hard_reset(struct mali_pp_core *core) { /* Bus must be stopped before calling this function */ @@ -206,7 +256,7 @@ _mali_osk_errcode_t mali_pp_hard_reset(struct mali_pp_core *core) MALI_DEBUG_PRINT(2, ("Mali PP: Hard reset of core %s\n", core->hw_core.description)); MALI_ASSERT_GROUP_LOCKED(core->group); - mali_pp_post_process_job(core); /* @@@@ is there some cases where it is unsafe to post process the job here? */ + mali_pp_post_process_job(core); /* @@@@ is there some cases where it is unsafe to post process the job here? */ /* Set register to a bogus value. The register will be used to detect when reset is complete */ mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_WRITE_BOUNDARY_LOW, reset_invalid_value); @@ -247,10 +297,11 @@ _mali_osk_errcode_t mali_pp_reset(struct mali_pp_core *core) MALI_DEBUG_PRINT(4, ("Mali PP: Reset of core %s\n", core->hw_core.description)); MALI_ASSERT_GROUP_LOCKED(core->group); - mali_pp_post_process_job(core); /* @@@@ is there some cases where it is unsafe to post process the job here? */ + mali_pp_post_process_job(core); /* @@@@ is there some cases where it is unsafe to post process the job here? */ mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_INT_MASK, 0); /* disable the IRQs */ + #if defined(USING_MALI200) /* On Mali-200, stop the bus, then do a hard reset of the core */ @@ -319,7 +370,10 @@ void mali_pp_job_start(struct mali_pp_core *core, struct mali_pp_job *job, u32 s MALI_DEBUG_ASSERT_POINTER(core); MALI_ASSERT_GROUP_LOCKED(core->group); - mali_hw_core_register_write_array_relaxed(&core->hw_core, MALI200_REG_ADDR_FRAME, frame_registers, MALI200_NUM_REGS_FRAME); + mali_hw_core_register_write_array_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_FRAME, frame_registers, MALI200_NUM_REGS_FRAME, mali_frame_registers_reset_values); + + _mali_osk_mem_barrier(); + if (0 != sub_job) { /* @@ -328,22 +382,34 @@ void mali_pp_job_start(struct mali_pp_core *core, struct mali_pp_job *job, u32 s * but we need to patch these for all other sub jobs */ mali_hw_core_register_write_relaxed(&core->hw_core, MALI200_REG_ADDR_FRAME, mali_pp_job_get_addr_frame(job, sub_job)); - mali_hw_core_register_write_relaxed(&core->hw_core, MALI200_REG_ADDR_STACK, mali_pp_job_get_addr_stack(job, sub_job)); + mali_hw_core_register_write_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_STACK, mali_pp_job_get_addr_stack(job, sub_job), mali_frame_registers_reset_values[MALI200_REG_ADDR_STACK/4]); } if (wb0_registers[0]) /* M200_WB0_REG_SOURCE_SELECT register */ { - mali_hw_core_register_write_array_relaxed(&core->hw_core, MALI200_REG_ADDR_WB0, wb0_registers, MALI200_NUM_REGS_WBx); + mali_hw_core_register_write_array_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_WB0, wb0_registers, MALI200_NUM_REGS_WBx, mali_wb_registers_reset_values); + } + else + { + mali_hw_core_register_write_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_WB0, 0, mali_wb_registers_reset_values[0] ); } if (wb1_registers[0]) /* M200_WB1_REG_SOURCE_SELECT register */ { - mali_hw_core_register_write_array_relaxed(&core->hw_core, MALI200_REG_ADDR_WB1, wb1_registers, MALI200_NUM_REGS_WBx); + mali_hw_core_register_write_array_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_WB1, wb1_registers, MALI200_NUM_REGS_WBx, mali_wb_registers_reset_values); + } + else + { + mali_hw_core_register_write_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_WB1, 0, mali_wb_registers_reset_values[0] ); } if (wb2_registers[0]) /* M200_WB2_REG_SOURCE_SELECT register */ { - mali_hw_core_register_write_array_relaxed(&core->hw_core, MALI200_REG_ADDR_WB2, wb2_registers, MALI200_NUM_REGS_WBx); + mali_hw_core_register_write_array_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_WB2, wb2_registers, MALI200_NUM_REGS_WBx, mali_wb_registers_reset_values); + } + else + { + mali_hw_core_register_write_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_WB2, 0, mali_wb_registers_reset_values[0] ); } /* This selects which performance counters we are reading */ @@ -352,13 +418,14 @@ void mali_pp_job_start(struct mali_pp_core *core, struct mali_pp_job *job, u32 s /* global_config has enabled HW counters, this will override anything specified by user space */ if (MALI_HW_CORE_NO_COUNTER != core->counter_src0_used) { - mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_0_SRC, core->counter_src0_used); - mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_0_ENABLE, MALI200_REG_VAL_PERF_CNT_ENABLE); + mali_hw_core_register_write_relaxed(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_0_SRC, core->counter_src0_used); + mali_hw_core_register_write_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_0_ENABLE, MALI200_REG_VAL_PERF_CNT_ENABLE, mali_perf_cnt_enable_reset_value); + } if (MALI_HW_CORE_NO_COUNTER != core->counter_src1_used) { - mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_1_SRC, core->counter_src1_used); - mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_1_ENABLE, MALI200_REG_VAL_PERF_CNT_ENABLE); + mali_hw_core_register_write_relaxed(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_1_SRC, core->counter_src1_used); + mali_hw_core_register_write_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_1_ENABLE, MALI200_REG_VAL_PERF_CNT_ENABLE, mali_perf_cnt_enable_reset_value); } } else @@ -370,15 +437,15 @@ void mali_pp_job_start(struct mali_pp_core *core, struct mali_pp_job *job, u32 s if (perf_counter_flag & _MALI_PERFORMANCE_COUNTER_FLAG_SRC0_ENABLE) { core->counter_src0_used = mali_pp_job_get_perf_counter_src0(job); - mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_0_SRC, core->counter_src0_used); - mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_0_ENABLE, MALI200_REG_VAL_PERF_CNT_ENABLE); + mali_hw_core_register_write_relaxed(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_0_SRC, core->counter_src0_used); + mali_hw_core_register_write_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_0_ENABLE, MALI200_REG_VAL_PERF_CNT_ENABLE, mali_perf_cnt_enable_reset_value); } if (perf_counter_flag & _MALI_PERFORMANCE_COUNTER_FLAG_SRC1_ENABLE) { core->counter_src1_used = mali_pp_job_get_perf_counter_src1(job); - mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_1_SRC, core->counter_src1_used); - mali_hw_core_register_write(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_1_ENABLE, MALI200_REG_VAL_PERF_CNT_ENABLE); + mali_hw_core_register_write_relaxed(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_1_SRC, core->counter_src1_used); + mali_hw_core_register_write_relaxed_conditional(&core->hw_core, MALI200_REG_ADDR_MGMT_PERF_CNT_1_ENABLE, MALI200_REG_VAL_PERF_CNT_ENABLE, mali_perf_cnt_enable_reset_value); } } } @@ -399,8 +466,8 @@ void mali_pp_job_start(struct mali_pp_core *core, struct mali_pp_job *job, u32 s core->timeout_job_id = mali_pp_job_get_id(job); #if MALI_TIMELINE_PROFILING_ENABLED - _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_SINGLE | MALI_PROFILING_MAKE_EVENT_CHANNEL_PP(core->core_id) | MALI_PROFILING_EVENT_REASON_SINGLE_HW_FLUSH, job->frame_builder_id, job->flush_id, 0, 0, 0); - _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_START|MALI_PROFILING_MAKE_EVENT_CHANNEL_PP(core->core_id), job->pid, job->tid, 0, 0, 0); + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_SINGLE | MALI_PROFILING_MAKE_EVENT_CHANNEL_PP(core->core_id) | MALI_PROFILING_EVENT_REASON_SINGLE_HW_FLUSH, mali_pp_job_get_frame_builder_id(job), mali_pp_job_get_flush_id(job), 0, 0, 0); + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_START|MALI_PROFILING_MAKE_EVENT_CHANNEL_PP(core->core_id), mali_pp_job_get_pid(job), mali_pp_job_get_tid(job), 0, 0, 0); #endif core->running_job = job; @@ -498,9 +565,7 @@ static void mali_pp_bottom_half(void *data) u32 irq_errors; #if MALI_TIMELINE_PROFILING_ENABLED -#if 0 /* Bottom half TLP logging is currently not supported */ - _mali_osk_profiling_add_event( MALI_PROFILING_EVENT_TYPE_START| MALI_PROFILING_EVENT_CHANNEL_SOFTWARE , _mali_osk_get_pid(), _mali_osk_get_tid(), 0, 0, 0); -#endif + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_START|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), MALI_PROFILING_MAKE_EVENT_DATA_CORE_PP(core->core_id), 0, 0); #endif mali_group_lock(core->group); /* Group lock grabbed in core handlers, but released in common group handler */ @@ -509,6 +574,9 @@ static void mali_pp_bottom_half(void *data) { MALI_PRINT_ERROR(("Interrupt bottom half of %s when core is OFF.", core->hw_core.description)); mali_group_unlock(core->group); +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } @@ -521,6 +589,9 @@ static void mali_pp_bottom_half(void *data) mali_pp_post_process_job(core); MALI_DEBUG_PRINT(3, ("Mali PP: Job completed, calling group handler\n")); mali_group_bottom_half(core->group, GROUP_EVENT_PP_JOB_COMPLETED); /* Will release group lock */ +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } @@ -535,6 +606,9 @@ static void mali_pp_bottom_half(void *data) MALI_PRINT_ERROR(("Mali PP: Unknown interrupt 0x%08X from core %s, aborting job\n", irq_readout, core->hw_core.description)); mali_group_bottom_half(core->group, GROUP_EVENT_PP_JOB_FAILED); /* Will release group lock */ +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } else if (MALI_TRUE == core->core_timed_out) /* SW timeout */ @@ -551,6 +625,9 @@ static void mali_pp_bottom_half(void *data) mali_group_unlock(core->group); } core->core_timed_out = MALI_FALSE; +#if MALI_TIMELINE_PROFILING_ENABLED + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); +#endif return; } else if (irq_readout & MALI200_REG_VAL_IRQ_HANG) @@ -567,9 +644,7 @@ static void mali_pp_bottom_half(void *data) mali_group_unlock(core->group); #if MALI_TIMELINE_PROFILING_ENABLED -#if 0 /* Bottom half TLP logging is currently not supported */ - _mali_osk_profiling_add_event( MALI_PROFILING_EVENT_TYPE_STOP| MALI_PROFILING_EVENT_CHANNEL_SOFTWARE , _mali_osk_get_pid(), _mali_osk_get_tid(), 0, 0, 0); -#endif + _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_STOP|MALI_PROFILING_EVENT_CHANNEL_SOFTWARE|MALI_PROFILING_EVENT_REASON_START_STOP_BOTTOM_HALF, 0, _mali_osk_get_tid(), 0, 0, 0); #endif } diff --git a/drivers/media/video/samsung/mali/common/mali_pp.h b/drivers/media/video/samsung/mali/common/mali_pp.h index 9b425a0..9b425a0 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_pp.h +++ b/drivers/media/video/samsung/mali/common/mali_pp.h diff --git a/drivers/media/video/samsung/mali/common/mali_pp_job.c b/drivers/media/video/samsung/mali/common/mali_pp_job.c index 1efcfda..3c23637 100644 --- a/drivers/media/video/samsung/mali/common/mali_pp_job.c +++ b/drivers/media/video/samsung/mali/common/mali_pp_job.c @@ -14,62 +14,41 @@ #include "mali_kernel_common.h" #include "mali_uk_types.h" -struct mali_pp_job *mali_pp_job_create(struct mali_session_data *session, _mali_uk_pp_start_job_s *args, u32 id) +struct mali_pp_job *mali_pp_job_create(struct mali_session_data *session, _mali_uk_pp_start_job_s *uargs, u32 id) { struct mali_pp_job *job; - if (args->num_cores > _MALI_PP_MAX_SUB_JOBS) - { - MALI_PRINT_ERROR(("Mali PP job: Too many sub jobs specified in job object\n")); - return NULL; - } - job = _mali_osk_malloc(sizeof(struct mali_pp_job)); if (NULL != job) { u32 i; - _mali_osk_list_init(&job->list); - job->session = session; - job->id = id; - job->user_id = args->user_job_ptr; - _mali_osk_memcpy(job->frame_registers, args->frame_registers, sizeof(job->frame_registers)); - _mali_osk_memcpy(job->frame_registers_addr_frame, args->frame_registers_addr_frame, sizeof(job->frame_registers_addr_frame)); - _mali_osk_memcpy(job->frame_registers_addr_stack, args->frame_registers_addr_stack, sizeof(job->frame_registers_addr_stack)); - /* Only copy write back registers for the units that are enabled */ - job->wb0_registers[0] = 0; - job->wb1_registers[0] = 0; - job->wb2_registers[0] = 0; - if (args->wb0_registers[0]) /* M200_WB0_REG_SOURCE_SELECT register */ - { - _mali_osk_memcpy(job->wb0_registers, args->wb0_registers, sizeof(job->wb0_registers)); - } - if (args->wb1_registers[0]) /* M200_WB1_REG_SOURCE_SELECT register */ + if (0 != _mali_osk_copy_from_user(&job->uargs, uargs, sizeof(_mali_uk_pp_start_job_s))) { - _mali_osk_memcpy(job->wb1_registers, args->wb1_registers, sizeof(job->wb1_registers)); + _mali_osk_free(job); + return NULL; } - if (args->wb2_registers[0]) /* M200_WB2_REG_SOURCE_SELECT register */ + + if (job->uargs.num_cores > _MALI_PP_MAX_SUB_JOBS) { - _mali_osk_memcpy(job->wb2_registers, args->wb2_registers, sizeof(job->wb2_registers)); + MALI_PRINT_ERROR(("Mali PP job: Too many sub jobs specified in job object\n")); + _mali_osk_free(job); + return NULL; } - job->perf_counter_flag = args->perf_counter_flag; - job->perf_counter_src0 = args->perf_counter_src0; - job->perf_counter_src1 = args->perf_counter_src1; - for (i = 0; i < args->num_cores; i++) + _mali_osk_list_init(&job->list); + job->session = session; + job->id = id; + for (i = 0; i < job->uargs.num_cores; i++) { job->perf_counter_value0[i] = 0; job->perf_counter_value1[i] = 0; } - job->sub_job_count = args->num_cores; job->sub_jobs_started = 0; job->sub_jobs_completed = 0; job->sub_job_errors = 0; - job->pid = _mali_osk_get_pid(); job->tid = _mali_osk_get_tid(); - job->frame_builder_id = args->frame_builder_id; - job->flush_id = args->flush_id; return job; } @@ -81,12 +60,3 @@ void mali_pp_job_delete(struct mali_pp_job *job) { _mali_osk_free(job); } - -_mali_osk_errcode_t mali_pp_job_check(struct mali_pp_job *job) -{ - if ((0 == job->frame_registers[0]) || (0 == job->frame_registers[1])) - { - return _MALI_OSK_ERR_FAULT; - } - return _MALI_OSK_ERR_OK; -} diff --git a/drivers/media/video/samsung/mali/common/mali_pp_job.h b/drivers/media/video/samsung/mali/common/mali_pp_job.h index 7fe87f8..7e25504 100644 --- a/drivers/media/video/samsung/mali/common/mali_pp_job.h +++ b/drivers/media/video/samsung/mali/common/mali_pp_job.h @@ -27,37 +27,28 @@ struct mali_pp_job { _mali_osk_list_t list; /**< Used to link jobs together in the scheduler queue */ struct mali_session_data *session; /**< Session which submitted this job */ + _mali_uk_pp_start_job_s uargs; /**< Arguments from user space */ u32 id; /**< identifier for this job in kernel space (sequencial numbering) */ - u32 user_id; /**< identifier for the job in user space */ - u32 frame_registers[_MALI_PP_MAX_FRAME_REGISTERS]; /**< core specific registers associated with this job, see ARM DDI0415A */ - u32 frame_registers_addr_frame[_MALI_PP_MAX_SUB_JOBS - 1]; /**< ADDR_FRAME registers for sub job 1-7 */ - u32 frame_registers_addr_stack[_MALI_PP_MAX_SUB_JOBS - 1]; /**< ADDR_STACK registers for sub job 1-7 */ - u32 wb0_registers[_MALI_PP_MAX_WB_REGISTERS]; /**< Write back unit 0 registers */ - u32 wb1_registers[_MALI_PP_MAX_WB_REGISTERS]; /**< Write back unit 1 registers */ - u32 wb2_registers[_MALI_PP_MAX_WB_REGISTERS]; /**< Write back unit 2 registers */ - u32 perf_counter_flag; /**< bitmask indicating which performance counters to enable, see \ref _MALI_PERFORMANCE_COUNTER_FLAG_SRC0_ENABLE and related macro definitions */ - u32 perf_counter_src0; /**< Source id for performance counter 0 (see ARM DDI0415A, Table 3-60) */ - u32 perf_counter_src1; /**< Source id for performance counter 1 (see ARM DDI0415A, Table 3-60) */ u32 perf_counter_value0[_MALI_PP_MAX_SUB_JOBS]; /**< Value of performance counter 0 (to be returned to user space), one for each sub job */ - u32 perf_counter_value1[_MALI_PP_MAX_SUB_JOBS]; /**< Value of performance counter 1 (to be returned to user space), one for each sub job */ - u32 sub_job_count; /**< Total number of sub-jobs in this superjob */ + u32 perf_counter_value1[_MALI_PP_MAX_SUB_JOBS]; /**< Value of performance counter 1 (to be returned to user space), one for each sub job */ u32 sub_jobs_started; /**< Total number of sub-jobs started (always started in ascending order) */ u32 sub_jobs_completed; /**< Number of completed sub-jobs in this superjob */ u32 sub_job_errors; /**< Bitfield with errors (errors for each single sub-job is or'ed together) */ u32 pid; /**< Process ID of submitting process */ u32 tid; /**< Thread ID of submitting thread */ - u32 frame_builder_id; /**< id of the originating frame builder */ - u32 flush_id; /**< flush id within the originating frame builder */ }; -struct mali_pp_job *mali_pp_job_create(struct mali_session_data *session, _mali_uk_pp_start_job_s *args, u32 id); +struct mali_pp_job *mali_pp_job_create(struct mali_session_data *session, _mali_uk_pp_start_job_s *uargs, u32 id); void mali_pp_job_delete(struct mali_pp_job *job); -_mali_osk_errcode_t mali_pp_job_check(struct mali_pp_job *job); - -/****************************************************** - * simple utility functions for dealing with pp jobs: - *****************************************************/ +MALI_STATIC_INLINE _mali_osk_errcode_t mali_pp_job_check(struct mali_pp_job *job) +{ + if ((0 == job->uargs.frame_registers[0]) || (0 == job->uargs.frame_registers[1])) + { + return _MALI_OSK_ERR_FAULT; + } + return _MALI_OSK_ERR_OK; +} MALI_STATIC_INLINE u32 mali_pp_job_get_id(struct mali_pp_job *job) { @@ -66,33 +57,43 @@ MALI_STATIC_INLINE u32 mali_pp_job_get_id(struct mali_pp_job *job) MALI_STATIC_INLINE u32 mali_pp_job_get_user_id(struct mali_pp_job *job) { - return job->user_id; + return job->uargs.user_job_ptr; } MALI_STATIC_INLINE u32 mali_pp_job_get_frame_builder_id(struct mali_pp_job *job) { - return job->frame_builder_id; + return job->uargs.frame_builder_id; } MALI_STATIC_INLINE u32 mali_pp_job_get_flush_id(struct mali_pp_job *job) { - return job->flush_id; + return job->uargs.flush_id; +} + +MALI_STATIC_INLINE u32 mali_pp_job_get_pid(struct mali_pp_job *job) +{ + return job->pid; +} + +MALI_STATIC_INLINE u32 mali_pp_job_get_tid(struct mali_pp_job *job) +{ + return job->tid; } MALI_STATIC_INLINE u32* mali_pp_job_get_frame_registers(struct mali_pp_job *job) { - return job->frame_registers; + return job->uargs.frame_registers; } MALI_STATIC_INLINE u32 mali_pp_job_get_addr_frame(struct mali_pp_job *job, u32 sub_job) { if (sub_job == 0) { - return job->frame_registers[MALI200_REG_ADDR_FRAME / sizeof(u32)]; + return job->uargs.frame_registers[MALI200_REG_ADDR_FRAME / sizeof(u32)]; } else if (sub_job < _MALI_PP_MAX_SUB_JOBS) { - return job->frame_registers_addr_frame[sub_job - 1]; + return job->uargs.frame_registers_addr_frame[sub_job - 1]; } return 0; @@ -102,11 +103,11 @@ MALI_STATIC_INLINE u32 mali_pp_job_get_addr_stack(struct mali_pp_job *job, u32 s { if (sub_job == 0) { - return job->frame_registers[MALI200_REG_ADDR_STACK / sizeof(u32)]; + return job->uargs.frame_registers[MALI200_REG_ADDR_STACK / sizeof(u32)]; } else if (sub_job < _MALI_PP_MAX_SUB_JOBS) { - return job->frame_registers_addr_stack[sub_job - 1]; + return job->uargs.frame_registers_addr_stack[sub_job - 1]; } return 0; @@ -114,32 +115,32 @@ MALI_STATIC_INLINE u32 mali_pp_job_get_addr_stack(struct mali_pp_job *job, u32 s MALI_STATIC_INLINE u32* mali_pp_job_get_wb0_registers(struct mali_pp_job *job) { - return job->wb0_registers; + return job->uargs.wb0_registers; } MALI_STATIC_INLINE u32* mali_pp_job_get_wb1_registers(struct mali_pp_job *job) { - return job->wb1_registers; + return job->uargs.wb1_registers; } MALI_STATIC_INLINE u32* mali_pp_job_get_wb2_registers(struct mali_pp_job *job) { - return job->wb2_registers; + return job->uargs.wb2_registers; } MALI_STATIC_INLINE void mali_pp_job_disable_wb0(struct mali_pp_job *job) { - job->wb0_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0; + job->uargs.wb0_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0; } MALI_STATIC_INLINE void mali_pp_job_disable_wb1(struct mali_pp_job *job) { - job->wb1_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0; + job->uargs.wb1_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0; } MALI_STATIC_INLINE void mali_pp_job_disable_wb2(struct mali_pp_job *job) { - job->wb2_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0; + job->uargs.wb2_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0; } MALI_STATIC_INLINE struct mali_session_data *mali_pp_job_get_session(struct mali_pp_job *job) @@ -149,7 +150,7 @@ MALI_STATIC_INLINE struct mali_session_data *mali_pp_job_get_session(struct mali MALI_STATIC_INLINE mali_bool mali_pp_job_has_unstarted_sub_jobs(struct mali_pp_job *job) { - return (job->sub_jobs_started < job->sub_job_count) ? MALI_TRUE : MALI_FALSE; + return (job->sub_jobs_started < job->uargs.num_cores) ? MALI_TRUE : MALI_FALSE; } /* Function used when we are terminating a session with jobs. Return TRUE if it has a rendering job. @@ -157,7 +158,7 @@ MALI_STATIC_INLINE mali_bool mali_pp_job_has_unstarted_sub_jobs(struct mali_pp_j MALI_STATIC_INLINE mali_bool mali_pp_job_is_currently_rendering_and_if_so_abort_new_starts(struct mali_pp_job *job) { /* All can not be started, since then it would not be in the job queue */ - MALI_DEBUG_ASSERT( job->sub_jobs_started != job->sub_job_count ); + MALI_DEBUG_ASSERT( job->sub_jobs_started != job->uargs.num_cores ); /* If at least one job is started */ if ( (job->sub_jobs_started > 0) ) @@ -165,7 +166,7 @@ MALI_STATIC_INLINE mali_bool mali_pp_job_is_currently_rendering_and_if_so_abort_ /* If at least one job is currently being rendered, and thus assigned to a group and core */ if (job->sub_jobs_started > job->sub_jobs_completed ) { - u32 jobs_remaining = job->sub_job_count - job->sub_jobs_started; + u32 jobs_remaining = job->uargs.num_cores - job->sub_jobs_started; job->sub_jobs_started += jobs_remaining; job->sub_jobs_completed += jobs_remaining; job->sub_job_errors += jobs_remaining; @@ -179,7 +180,7 @@ MALI_STATIC_INLINE mali_bool mali_pp_job_is_currently_rendering_and_if_so_abort_ MALI_STATIC_INLINE mali_bool mali_pp_job_is_complete(struct mali_pp_job *job) { - return (job->sub_job_count == job->sub_jobs_completed) ? MALI_TRUE : MALI_FALSE; + return (job->uargs.num_cores == job->sub_jobs_completed) ? MALI_TRUE : MALI_FALSE; } MALI_STATIC_INLINE u32 mali_pp_job_get_first_unstarted_sub_job(struct mali_pp_job *job) @@ -189,7 +190,7 @@ MALI_STATIC_INLINE u32 mali_pp_job_get_first_unstarted_sub_job(struct mali_pp_jo MALI_STATIC_INLINE u32 mali_pp_job_get_sub_job_count(struct mali_pp_job *job) { - return job->sub_job_count; + return job->uargs.num_cores; } MALI_STATIC_INLINE void mali_pp_job_mark_sub_job_started(struct mali_pp_job *job, u32 sub_job) @@ -199,6 +200,15 @@ MALI_STATIC_INLINE void mali_pp_job_mark_sub_job_started(struct mali_pp_job *job job->sub_jobs_started++; } +MALI_STATIC_INLINE void mali_pp_job_mark_sub_job_not_stated(struct mali_pp_job *job, u32 sub_job) +{ + /* This is only safe on Mali-200. */ +#if !defined(USING_MALI200) + MALI_DEBUG_ASSERT(0); +#endif + job->sub_jobs_started--; +} + MALI_STATIC_INLINE void mali_pp_job_mark_sub_job_completed(struct mali_pp_job *job, mali_bool success) { job->sub_jobs_completed++; @@ -217,19 +227,34 @@ MALI_STATIC_INLINE mali_bool mali_pp_job_was_success(struct mali_pp_job *job) return MALI_FALSE; } +MALI_STATIC_INLINE mali_bool mali_pp_job_has_active_barrier(struct mali_pp_job *job) +{ + return job->uargs.flags & _MALI_PP_JOB_FLAG_BARRIER ? MALI_TRUE : MALI_FALSE; +} + +MALI_STATIC_INLINE void mali_pp_job_barrier_enforced(struct mali_pp_job *job) +{ + job->uargs.flags &= ~_MALI_PP_JOB_FLAG_BARRIER; +} + +MALI_STATIC_INLINE mali_bool mali_pp_job_use_no_notification(struct mali_pp_job *job) +{ + return job->uargs.flags & _MALI_PP_JOB_FLAG_NO_NOTIFICATION ? MALI_TRUE : MALI_FALSE; +} + MALI_STATIC_INLINE u32 mali_pp_job_get_perf_counter_flag(struct mali_pp_job *job) { - return job->perf_counter_flag; + return job->uargs.perf_counter_flag; } MALI_STATIC_INLINE u32 mali_pp_job_get_perf_counter_src0(struct mali_pp_job *job) { - return job->perf_counter_src0; + return job->uargs.perf_counter_src0; } MALI_STATIC_INLINE u32 mali_pp_job_get_perf_counter_src1(struct mali_pp_job *job) { - return job->perf_counter_src1; + return job->uargs.perf_counter_src1; } MALI_STATIC_INLINE u32 mali_pp_job_get_perf_counter_value0(struct mali_pp_job *job, u32 sub_job) diff --git a/drivers/media/video/samsung/mali/common/mali_pp_scheduler.c b/drivers/media/video/samsung/mali/common/mali_pp_scheduler.c index ce07a76..eedf661 100644 --- a/drivers/media/video/samsung/mali/common/mali_pp_scheduler.c +++ b/drivers/media/video/samsung/mali/common/mali_pp_scheduler.c @@ -17,6 +17,8 @@ #include "mali_pp_job.h" #include "mali_group.h" #include "mali_cluster.h" +#include "mali_osk_profiling.h" + /* Maximum of 8 PP cores (a group can only have maximum of 1 PP core) */ #define MALI_MAX_NUMBER_OF_PP_GROUPS 8 @@ -38,10 +40,15 @@ struct mali_pp_slot * so we don't need to take the group lock so often (and also avoid clutter with the working lock) */ enum mali_pp_slot_state state; + struct mali_session_data *session; + struct mali_pp_job *job; + u32 subjob; }; static u32 pp_version = 0; static _MALI_OSK_LIST_HEAD(job_queue); /* List of jobs with some unscheduled work */ +static u32 job_queue_depth; + static struct mali_pp_slot slots[MALI_MAX_NUMBER_OF_PP_GROUPS]; static u32 num_slots = 0; static u32 num_slots_idle = 0; @@ -60,7 +67,7 @@ _mali_osk_errcode_t mali_pp_scheduler_initialize(void) _MALI_OSK_INIT_LIST_HEAD(&job_queue); - pp_scheduler_lock = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED |_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_SCHEDULER); + pp_scheduler_lock = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_SPINLOCK_IRQ |_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_SCHEDULER); if (NULL == pp_scheduler_lock) { return _MALI_OSK_ERR_NOMEM; @@ -91,6 +98,7 @@ _mali_osk_errcode_t mali_pp_scheduler_initialize(void) } slots[num_slots].group = group; slots[num_slots].state = MALI_PP_SLOT_STATE_IDLE; + slots[num_slots].session = NULL; num_slots++; num_slots_idle++; } @@ -138,151 +146,186 @@ MALI_STATIC_INLINE void mali_pp_scheduler_assert_locked(void) #define MALI_ASSERT_PP_SCHEDULER_LOCKED() #endif -static void mali_pp_scheduler_schedule(void) +static mali_bool mali_pp_scheduler_session_has_running_jobs(struct mali_session_data *session) { u32 i; - struct mali_pp_job *job; -#if MALI_PP_SCHEDULER_FORCE_NO_JOB_OVERLAP_BETWEEN_APPS - struct mali_session_data * session; -#endif MALI_ASSERT_PP_SCHEDULER_LOCKED(); - if (0 < pause_count || 0 == num_slots_idle || _mali_osk_list_empty(&job_queue)) + if (num_slots_idle == num_slots) { - MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Nothing to schedule (paused=%u, idle slots=%u)\n", - pause_count, num_slots_idle)); - return; /* Nothing to do, so early out */ + return MALI_FALSE; } - -#if MALI_PP_SCHEDULER_FORCE_NO_JOB_OVERLAP - if ( num_slots_idle < num_slots ) - { - MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Job not started, since only %d/%d cores are available\n", num_slots_idle,num_slots)); - return; - } -#endif - -#if MALI_PP_SCHEDULER_FORCE_NO_JOB_OVERLAP_BETWEEN_APPS - /* Finding initial session for the PP cores */ - job = _MALI_OSK_LIST_ENTRY(job_queue.next, struct mali_pp_job, list); - session = job->session; - if ( num_slots != num_slots_idle ) + for (i = 0; i < num_slots; i++) { - for (i = 0; (i < num_slots) ; i++) - { - if ( slots[i].state == MALI_PP_SLOT_STATE_IDLE ) + if (MALI_PP_SLOT_STATE_WORKING == slots[i].state) + { + if (slots[i].session == session) { - continue; + return MALI_TRUE; } - session = mali_group_get_session(slots[i].group); - break; } } -#endif - for (i = 0; (i < num_slots) && (0 < num_slots_idle); i++) + return MALI_FALSE; +} + +static mali_bool slots_available(void) +{ + return num_slots_idle > 0; +} + +static void mali_pp_scheduler_schedule(void) +{ + struct mali_pp_job *job; + + if (0 < pause_count || 0 == num_slots_idle || 0 == job_queue_depth) { - u32 sub_job; - - if (_mali_osk_list_empty(&job_queue)) /* move this check down to where we know we have started all sub jobs for this job??? */ - { - break; /* No more jobs to schedule, so early out */ - } + MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Nothing to schedule (paused=%u, idle slots=%u)\n", + pause_count, num_slots_idle)); + return; /* Nothing to do, so early out */ + } - if (MALI_PP_SLOT_STATE_IDLE != slots[i].state) + while(slots_available() && 0 < job_queue_depth) + { + u32 i, slot_count; + struct mali_pp_slot *reserved_slots[num_slots]; + struct mali_session_data *session; + + mali_pp_scheduler_lock(); + /* Get job */ + if (_mali_osk_list_empty(&job_queue) || !slots_available()) { - continue; + mali_pp_scheduler_unlock(); + break; /* No more jobs to schedule, so early out */ } - job = _MALI_OSK_LIST_ENTRY(job_queue.next, struct mali_pp_job, list); MALI_DEBUG_ASSERT(mali_pp_job_has_unstarted_sub_jobs(job)); /* All jobs on the job_queue should have unstarted sub jobs */ - - #if MALI_PP_SCHEDULER_KEEP_SUB_JOB_STARTS_ALIGNED - if ( (0==job->sub_jobs_started) && (num_slots_idle < num_slots) && (job->sub_job_count > num_slots_idle)) - { - MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Job with %d subjobs not started, since only %d/%d cores are available\n", job->sub_job_count, num_slots_idle,num_slots)); - return; - } - #endif - - #if MALI_PP_SCHEDULER_FORCE_NO_JOB_OVERLAP_BETWEEN_APPS - if ( job->session != session ) + session = mali_pp_job_get_session(job); + + if (MALI_TRUE == mali_pp_job_has_active_barrier(job)) { - MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Job not started since existing job is from another application\n")); - return; + if (MALI_TRUE == mali_pp_scheduler_session_has_running_jobs(mali_pp_job_get_session(job))) + { + /* There is already a running job from this + * session, so we need to enforce the barrier */ + mali_pp_scheduler_unlock(); + return; + } + else + { + /* Barrier is now enforced, update job object + * so we don't delay execution of sub-jobs */ + mali_pp_job_barrier_enforced(job); + } } - #endif - - sub_job = mali_pp_job_get_first_unstarted_sub_job(job); - MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Starting job %u (0x%08X) part %u/%u\n", mali_pp_job_get_id(job), job, sub_job + 1, mali_pp_job_get_sub_job_count(job))); - if (_MALI_OSK_ERR_OK == mali_group_start_pp_job(slots[i].group, job, sub_job)) + /* Reserve slots */ + for (i = 0, slot_count = 0; i < num_slots; i++) { - MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Job %u (0x%08X) part %u/%u started\n", mali_pp_job_get_id(job), job, sub_job + 1, mali_pp_job_get_sub_job_count(job))); + struct mali_pp_slot *slot = &slots[i]; + + if (MALI_PP_SLOT_STATE_IDLE != slot->state) continue; - /* Mark this sub job as started */ - mali_pp_job_mark_sub_job_started(job, sub_job); + slot->state = MALI_PP_SLOT_STATE_WORKING; + slot->session = session; + slot->job = job; + slot->subjob = mali_pp_job_get_first_unstarted_sub_job(job); + mali_pp_job_mark_sub_job_started(job, slot->subjob); + --job_queue_depth; - /* Mark slot as busy */ - slots[i].state = MALI_PP_SLOT_STATE_WORKING; - num_slots_idle--; + --num_slots_idle; + reserved_slots[slot_count++] = slot; if (!mali_pp_job_has_unstarted_sub_jobs(job)) { - /* - * All sub jobs have now started for this job, remove this job from the job queue. - * The job will now only be referred to by the slots which are running it. - * The last slot to complete will make sure it is returned to user space. - */ _mali_osk_list_del(&job->list); -#if MALI_PP_SCHEDULER_FORCE_NO_JOB_OVERLAP - MALI_DEBUG_PRINT(6, ("Mali PP scheduler: Skip scheduling more jobs when MALI_PP_SCHEDULER_FORCE_NO_JOB_OVERLAP is set.\n")); - return; -#endif + break; } } - else + + MALI_DEBUG_ASSERT(0 < slot_count); + + mali_pp_scheduler_unlock(); + + /* Start (sub)job(s) on core(s) */ + for(i = 0; i < slot_count; i++) { - MALI_DEBUG_PRINT(3, ("Mali PP scheduler: Failed to start PP job\n")); - return; + struct mali_pp_slot *slot = reserved_slots[i]; + struct mali_pp_job *job; + u32 subjob; + + MALI_DEBUG_ASSERT_POINTER(slot); + MALI_DEBUG_ASSERT(MALI_PP_SLOT_STATE_WORKING == slot->state); + MALI_DEBUG_ASSERT_POINTER(slot->job); + + job = slot->job; + subjob = slot->subjob; + + if (_MALI_OSK_ERR_OK == mali_group_start_pp_job(slot->group, slot->job, slot->subjob)) + { + MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Job %u (0x%08X) part %u/%u started\n", + mali_pp_job_get_id(job), job, subjob + 1, + mali_pp_job_get_sub_job_count(job))); + } + else + { + MALI_DEBUG_PRINT(3, ("Mali PP scheduler: Failed to start PP job\n")); + /* This can only happen on Mali-200 */ +#if !defined(USING_MALI200) + MALI_DEBUG_ASSERT(0); +#endif + mali_pp_scheduler_lock(); + /* Put job back on queue */ + mali_pp_job_mark_sub_job_not_stated(job, subjob); + _mali_osk_list_add(&job->list, &job_queue); + /* Set slot idle */ + slot->state = MALI_PP_SLOT_STATE_IDLE; + slot->session = NULL; + slot->job = NULL; + slot->subjob = 0; + mali_pp_scheduler_unlock(); + } } } } static void mali_pp_scheduler_return_job_to_user(struct mali_pp_job *job) { - _mali_osk_notification_t *notobj = _mali_osk_notification_create(_MALI_NOTIFICATION_PP_FINISHED, sizeof(_mali_uk_pp_job_finished_s)); - if (NULL != notobj) + if (MALI_FALSE == mali_pp_job_use_no_notification(job)) { - u32 i; - u32 sub_jobs = mali_pp_job_get_sub_job_count(job); - mali_bool success = mali_pp_job_was_success(job); - - _mali_uk_pp_job_finished_s *jobres = notobj->result_buffer; - _mali_osk_memset(jobres, 0, sizeof(_mali_uk_pp_job_finished_s)); /* @@@@ can be removed once we initialize all members in this struct */ - jobres->user_job_ptr = mali_pp_job_get_user_id(job); - if (MALI_TRUE == success) + _mali_osk_notification_t *notobj = _mali_osk_notification_create(_MALI_NOTIFICATION_PP_FINISHED, sizeof(_mali_uk_pp_job_finished_s)); + if (NULL != notobj) { - jobres->status = _MALI_UK_JOB_STATUS_END_SUCCESS; + u32 i; + u32 sub_jobs = mali_pp_job_get_sub_job_count(job); + mali_bool success = mali_pp_job_was_success(job); + + _mali_uk_pp_job_finished_s *jobres = notobj->result_buffer; + _mali_osk_memset(jobres, 0, sizeof(_mali_uk_pp_job_finished_s)); /* @@@@ can be removed once we initialize all members in this struct */ + jobres->user_job_ptr = mali_pp_job_get_user_id(job); + if (MALI_TRUE == success) + { + jobres->status = _MALI_UK_JOB_STATUS_END_SUCCESS; + } + else + { + jobres->status = _MALI_UK_JOB_STATUS_END_UNKNOWN_ERR; + } + + for (i = 0; i < sub_jobs; i++) + { + jobres->perf_counter0[i] = mali_pp_job_get_perf_counter_value0(job, i); + jobres->perf_counter1[i] = mali_pp_job_get_perf_counter_value1(job, i); + } + + mali_session_send_notification(mali_pp_job_get_session(job), notobj); } else { - jobres->status = _MALI_UK_JOB_STATUS_END_UNKNOWN_ERR; + MALI_PRINT_ERROR(("Mali PP scheduler: Unable to allocate notification object\n")); } - - for (i = 0; i < sub_jobs; i++) - { - jobres->perf_counter0[i] = mali_pp_job_get_perf_counter_value0(job, i); - jobres->perf_counter1[i] = mali_pp_job_get_perf_counter_value1(job, i); - } - - mali_session_send_notification(mali_pp_job_get_session(job), notobj); - } - else - { - MALI_PRINT_ERROR(("Mali PP scheduler: Unable to allocate notification object\n")); } mali_pp_job_delete(job); @@ -290,34 +333,42 @@ static void mali_pp_scheduler_return_job_to_user(struct mali_pp_job *job) void mali_pp_scheduler_do_schedule(void) { - mali_pp_scheduler_lock(); - mali_pp_scheduler_schedule(); - - mali_pp_scheduler_unlock(); } void mali_pp_scheduler_job_done(struct mali_group *group, struct mali_pp_job *job, u32 sub_job, mali_bool success) { u32 i; + struct mali_pp_slot *slot = NULL; mali_bool job_is_done; - MALI_DEBUG_PRINT(3, ("Mali PP scheduler: Job %u (0x%08X) part %u/%u completed (%s)\n", mali_pp_job_get_id(job), job, sub_job + 1, mali_pp_job_get_sub_job_count(job), success ? "success" : "failure")); + MALI_DEBUG_PRINT(3, ("Mali PP scheduler: Job %u (0x%08X) part %u/%u completed (%s)\n", + mali_pp_job_get_id(job), + job, sub_job + 1, + mali_pp_job_get_sub_job_count(job), + success ? "success" : "failure")); mali_pp_scheduler_lock(); + mali_pp_job_mark_sub_job_completed(job, success); + /* Find slot which was running this job */ for (i = 0; i < num_slots; i++) { - if (slots[i].group == group) - { - MALI_DEBUG_ASSERT(MALI_PP_SLOT_STATE_WORKING == slots[i].state); - slots[i].state = MALI_PP_SLOT_STATE_IDLE; - num_slots_idle++; - mali_pp_job_mark_sub_job_completed(job, success); - } + slot = &slots[i]; + if (slot->group == group) + break; } + MALI_DEBUG_ASSERT_POINTER(slot); + + slot->state = MALI_PP_SLOT_STATE_IDLE; + slot->session = NULL; + slot->job = NULL; + slot->subjob = 0; + + num_slots_idle++; + /* If paused, then this was the last job, so wake up sleeping workers */ if (pause_count > 0) { @@ -327,10 +378,6 @@ void mali_pp_scheduler_job_done(struct mali_group *group, struct mali_pp_job *jo */ _mali_osk_wait_queue_wake_up(pp_scheduler_working_wait_queue); } - else - { - mali_pp_scheduler_schedule(); - } job_is_done = mali_pp_job_is_complete(job); @@ -342,6 +389,8 @@ void mali_pp_scheduler_job_done(struct mali_group *group, struct mali_pp_job *jo MALI_DEBUG_PRINT(4, ("Mali PP scheduler: All parts completed for job %u (0x%08X)\n", mali_pp_job_get_id(job), job)); mali_pp_scheduler_return_job_to_user(job); } + + mali_pp_scheduler_schedule(); } void mali_pp_scheduler_suspend(void) @@ -350,11 +399,7 @@ void mali_pp_scheduler_suspend(void) pause_count++; /* Increment the pause_count so that no more jobs will be scheduled */ mali_pp_scheduler_unlock(); - /*mali_pp_scheduler_working_lock();*/ - /* We have now aquired the working lock, which means that we have successfully paused the scheduler */ - /*mali_pp_scheduler_working_unlock();*/ - - /* go to sleep. When woken up again (in mali_pp_scheduler_job_done), the + /* Go to sleep. When woken up again (in mali_pp_scheduler_job_done), the * mali_pp_scheduler_suspended() function will be called. This will return true * iff state is idle and pause_count > 0, so if the core is active this * will not do anything. @@ -373,17 +418,17 @@ void mali_pp_scheduler_resume(void) mali_pp_scheduler_unlock(); } -_mali_osk_errcode_t _mali_ukk_pp_start_job(_mali_uk_pp_start_job_s *args) +_mali_osk_errcode_t _mali_ukk_pp_start_job(void *ctx, _mali_uk_pp_start_job_s *uargs) { struct mali_session_data *session; struct mali_pp_job *job; - MALI_DEBUG_ASSERT_POINTER(args); - MALI_DEBUG_ASSERT_POINTER(args->ctx); + MALI_DEBUG_ASSERT_POINTER(uargs); + MALI_DEBUG_ASSERT_POINTER(ctx); - session = (struct mali_session_data*)args->ctx; + session = (struct mali_session_data*)ctx; - job = mali_pp_job_create(session, args, mali_scheduler_get_new_id()); + job = mali_pp_job_create(session, uargs, mali_scheduler_get_new_id()); if (NULL == job) { return _MALI_OSK_ERR_NOMEM; @@ -397,16 +442,24 @@ _mali_osk_errcode_t _mali_ukk_pp_start_job(_mali_uk_pp_start_job_s *args) return _MALI_OSK_ERR_OK; /* User is notified via a notification, so this call is ok */ } +#if PROFILING_SKIP_PP_JOBS || PROFILING_SKIP_PP_AND_GP_JOBS +#warning PP jobs will not be executed + mali_pp_scheduler_return_job_to_user(job); + return _MALI_OSK_ERR_OK; +#endif + mali_pp_scheduler_lock(); + job_queue_depth += mali_pp_job_get_sub_job_count(job); _mali_osk_list_addtail(&job->list, &job_queue); - MALI_DEBUG_PRINT(3, ("Mali PP scheduler: Job %u (0x%08X) with %u parts queued\n", mali_pp_job_get_id(job), job, mali_pp_job_get_sub_job_count(job))); - - mali_pp_scheduler_schedule(); + MALI_DEBUG_PRINT(3, ("Mali PP scheduler: Job %u (0x%08X) with %u parts queued\n", + mali_pp_job_get_id(job), job, mali_pp_job_get_sub_job_count(job))); mali_pp_scheduler_unlock(); + if (slots_available()) mali_pp_scheduler_schedule(); + return _MALI_OSK_ERR_OK; } @@ -437,9 +490,8 @@ void _mali_ukk_pp_job_disable_wb(_mali_uk_pp_disable_wb_s *args) session = (struct mali_session_data*)args->ctx; - mali_pp_scheduler_lock(); - /* Check queue for jobs that match */ + mali_pp_scheduler_lock(); _MALI_OSK_LIST_FOREACHENTRY(job, tmp, &job_queue, struct mali_pp_job, list) { if (mali_pp_job_get_session(job) == session && @@ -461,7 +513,6 @@ void _mali_ukk_pp_job_disable_wb(_mali_uk_pp_disable_wb_s *args) break; } } - mali_pp_scheduler_unlock(); } @@ -479,6 +530,7 @@ void mali_pp_scheduler_abort_session(struct mali_session_data *session) if (mali_pp_job_get_session(job) == session) { _mali_osk_list_del(&(job->list)); + job_queue_depth -= mali_pp_job_get_sub_job_count(job) - mali_pp_job_get_first_unstarted_sub_job(job); if ( mali_pp_job_is_currently_rendering_and_if_so_abort_new_starts(job) ) { @@ -499,14 +551,9 @@ void mali_pp_scheduler_abort_session(struct mali_session_data *session) { struct mali_group *group = slots[i].group; - MALI_DEBUG_PRINT(5, ("PP sched abort: Looking at group 0x%08x\n", group)); + MALI_DEBUG_PRINT(5, ("PP sched abort: Attempting abort for session 0x%08x on group 0x%08x\n", session, group)); - if (MALI_PP_SLOT_STATE_WORKING == slots[i].state) - { - MALI_DEBUG_PRINT(4, ("Mali PP scheduler: Aborting session 0x%08x from group 0x%08x\n", session, group)); - - mali_group_abort_session(group, session); - } + mali_group_abort_session(group, session); } } @@ -521,6 +568,11 @@ static mali_bool mali_pp_scheduler_is_suspended(void) return ret; } +int mali_pp_scheduler_get_queue_depth(void) +{ + return job_queue_depth; +} + #if MALI_STATE_TRACKING u32 mali_pp_scheduler_dump_state(char *buf, u32 size) { diff --git a/drivers/media/video/samsung/mali/common/mali_pp_scheduler.h b/drivers/media/video/samsung/mali/common/mali_pp_scheduler.h index 48eb3bd..59bf403 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_pp_scheduler.h +++ b/drivers/media/video/samsung/mali/common/mali_pp_scheduler.h @@ -33,6 +33,7 @@ void mali_pp_scheduler_resume(void); */ void mali_pp_scheduler_abort_session(struct mali_session_data *session); +int mali_pp_scheduler_get_queue_depth(void); u32 mali_pp_scheduler_dump_state(char *buf, u32 size); #endif /* __MALI_PP_SCHEDULER_H__ */ diff --git a/drivers/media/video/samsung/mali/common/mali_scheduler.c b/drivers/media/video/samsung/mali/common/mali_scheduler.c index 52159a0..f360209 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_scheduler.c +++ b/drivers/media/video/samsung/mali/common/mali_scheduler.c @@ -34,3 +34,4 @@ u32 mali_scheduler_get_new_id(void) u32 job_id = _mali_osk_atomic_inc_return(&mali_job_autonumber); return job_id; } + diff --git a/drivers/media/video/samsung/mali/common/mali_scheduler.h b/drivers/media/video/samsung/mali/common/mali_scheduler.h index 74f0947..74f0947 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_scheduler.h +++ b/drivers/media/video/samsung/mali/common/mali_scheduler.h diff --git a/drivers/media/video/samsung/mali/common/mali_session.h b/drivers/media/video/samsung/mali/common/mali_session.h index b47c340..c8640b5 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_session.h +++ b/drivers/media/video/samsung/mali/common/mali_session.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010, 2012 ARM Limited. All rights reserved. + * Copyright (C) 2010-2012 ARM Limited. All rights reserved. * * This program is free software and is provided to you under the terms of the GNU General Public License version 2 * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence. diff --git a/drivers/media/video/samsung/mali/common/mali_ukk.h b/drivers/media/video/samsung/mali/common/mali_ukk.h index 8ff2002..6d41b6e 100644 --- a/drivers/media/video/samsung/mali/common/mali_ukk.h +++ b/drivers/media/video/samsung/mali/common/mali_ukk.h @@ -17,7 +17,7 @@ #define __MALI_UKK_H__ #include "mali_osk.h" -#include "../linux/mali_uk_types.h" +#include "mali_uk_types.h" #ifdef __cplusplus extern "C" @@ -218,55 +218,6 @@ _mali_osk_errcode_t _mali_ukk_close( void **context ); * * @{ */ -/** @brief Returns the size of the buffer needed for a _mali_ukk_get_system_info call - * - * This function must be called before a call is made to - * _mali_ukk_get_system_info, so that memory of the correct size can be - * allocated, and a pointer to this memory written into the system_info member - * of _mali_uk_get_system_info_s. - * - * @param args see _mali_uk_get_system_info_size_s in "mali_utgard_uk_types.h" - * @return _MALI_OSK_ERR_OK on success, otherwise a suitable _mali_osk_errcode_t on failure. - */ -_mali_osk_errcode_t _mali_ukk_get_system_info_size( _mali_uk_get_system_info_size_s *args ); - -/** @brief Returns information about the system (cores and memory banks) - * - * A buffer for this needs to be allocated by the caller. The size of the buffer required is returned by - * _mali_ukk_get_system_info_size(). The user is responsible for freeing the buffer. - * - * The _mali_system_info structure will be written to the start of this buffer, - * and the core_info and mem_info lists will be written to locations inside - * the buffer, and will be suitably aligned. - * - * Under OS implementations of the U/K interface we need to pack/unpack - * pointers across the user/kernel boundary. This has required that we malloc() - * an intermediate buffer inside the kernel-side U/K interface, and free it - * before returning to user-side. To avoid modifying common code, we do the - * following pseudo-code, which we shall call 'pointer switching': - * - * @code - * { - * Copy_From_User(kargs, args, ... ); - * void __user * local_ptr = kargs->system_info; - * kargs->system_info = _mali_osk_malloc( ... ); - * _mali_ukk_get_system_info( kargs ); - * Copy_To_User( local_ptr, kargs->system_info, ... ); - * _mali_osk_free( kargs->system_info ); - * } - * @endcode - * @note The user-side's args->system_info members was unmodified here. - * - * However, the current implementation requires an extra ukk_private word so that the common code can work out - * how to patch pointers to user-mode for an OS's U/K implementation, this should be set to the user-space - * destination address for pointer-patching to occur. When NULL, it is unused, an no pointer-patching occurs in the - * common code. - * - * @param args see _mali_uk_get_system_info_s in "mali_utgard_uk_types.h" - * @return _MALI_OSK_ERR_OK on success, otherwise a suitable _mali_osk_errcode_t on failure. - */ -_mali_osk_errcode_t _mali_ukk_get_system_info( _mali_uk_get_system_info_s *args ); - /** @brief Waits for a job notification. * * Sleeps until notified or a timeout occurs. Returns information about the notification. @@ -498,10 +449,11 @@ _mali_osk_errcode_t _mali_ukk_va_to_mali_pa( _mali_uk_va_to_mali_pa_s * args ); * * Job completion can be awaited with _mali_ukk_wait_for_notification(). * - * @param args see _mali_uk_pp_start_job_s in "mali_utgard_uk_types.h" + * @oaram ctx user-kernel context (mali_session) + * @param uargs see _mali_uk_pp_start_job_s in "mali_utgard_uk_types.h". Use _mali_osk_copy_from_user to retrieve data! * @return _MALI_OSK_ERR_OK on success, otherwise a suitable _mali_osk_errcode_t on failure. */ -_mali_osk_errcode_t _mali_ukk_pp_start_job( _mali_uk_pp_start_job_s *args ); +_mali_osk_errcode_t _mali_ukk_pp_start_job( void *ctx, _mali_uk_pp_start_job_s *uargs ); /** @brief Returns the number of Fragment Processors in the system * @@ -551,10 +503,11 @@ void _mali_ukk_pp_job_disable_wb(_mali_uk_pp_disable_wb_s *args); * * Job completion can be awaited with _mali_ukk_wait_for_notification(). * - * @param args see _mali_uk_gp_start_job_s in "mali_utgard_uk_types.h" + * @oaram ctx user-kernel context (mali_session) + * @param uargs see _mali_uk_gp_start_job_s in "mali_utgard_uk_types.h". Use _mali_osk_copy_from_user to retrieve data! * @return _MALI_OSK_ERR_OK on success, otherwise a suitable _mali_osk_errcode_t on failure. */ -_mali_osk_errcode_t _mali_ukk_gp_start_job( _mali_uk_gp_start_job_s *args ); +_mali_osk_errcode_t _mali_ukk_gp_start_job( void *ctx, _mali_uk_gp_start_job_s *uargs ); /** @brief Returns the number of Vertex Processors in the system. * diff --git a/drivers/media/video/samsung/mali/common/mali_user_settings_db.c b/drivers/media/video/samsung/mali/common/mali_user_settings_db.c index 681c2b0..d3f1e50 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_user_settings_db.c +++ b/drivers/media/video/samsung/mali/common/mali_user_settings_db.c @@ -82,7 +82,7 @@ _mali_osk_errcode_t _mali_ukk_get_user_settings(_mali_uk_get_user_settings_s *ar { MALI_DEBUG_ASSERT_POINTER(args); - _mali_osk_memcpy(args->settings, mali_user_settings, (sizeof(u32) * _MALI_UK_USER_SETTING_MAX)); + _mali_osk_memcpy(args->settings, mali_user_settings, sizeof(mali_user_settings)); return _MALI_OSK_ERR_OK; } diff --git a/drivers/media/video/samsung/mali/common/mali_user_settings_db.h b/drivers/media/video/samsung/mali/common/mali_user_settings_db.h index fbb9415..fbb9415 100755..100644 --- a/drivers/media/video/samsung/mali/common/mali_user_settings_db.h +++ b/drivers/media/video/samsung/mali/common/mali_user_settings_db.h |