| /* |
| * Copyright (C) 2011-2016 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. |
| * |
| * A copy of the licence is included with the program, and can also be obtained from Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| */ |
| |
| #ifndef __MALI_GROUP_H__ |
| #define __MALI_GROUP_H__ |
| |
| #include "mali_osk.h" |
| #include "mali_l2_cache.h" |
| #include "mali_mmu.h" |
| #include "mali_gp.h" |
| #include "mali_pp.h" |
| #include "mali_session.h" |
| #include "mali_osk_profiling.h" |
| |
| /** |
| * @brief Default max runtime [ms] for a core job - used by timeout timers |
| */ |
| #define MALI_MAX_JOB_RUNTIME_DEFAULT 5000 |
| |
| extern int mali_max_job_runtime; |
| |
| #define MALI_MAX_NUMBER_OF_GROUPS 10 |
| #define MALI_MAX_NUMBER_OF_PHYSICAL_PP_GROUPS 8 |
| |
| enum mali_group_state { |
| MALI_GROUP_STATE_INACTIVE, |
| MALI_GROUP_STATE_ACTIVATION_PENDING, |
| MALI_GROUP_STATE_ACTIVE, |
| }; |
| |
| /** |
| * The structure represents a render group |
| * A render group is defined by all the cores that share the same Mali MMU |
| */ |
| |
| struct mali_group { |
| struct mali_mmu_core *mmu; |
| struct mali_session_data *session; |
| |
| enum mali_group_state state; |
| mali_bool power_is_on; |
| |
| mali_bool is_working; |
| unsigned long start_time; /* in ticks */ |
| |
| struct mali_gp_core *gp_core; |
| struct mali_gp_job *gp_running_job; |
| |
| struct mali_pp_core *pp_core; |
| struct mali_pp_job *pp_running_job; |
| u32 pp_running_sub_job; |
| |
| struct mali_pm_domain *pm_domain; |
| |
| struct mali_l2_cache_core *l2_cache_core[2]; |
| u32 l2_cache_core_ref_count[2]; |
| |
| /* Parent virtual group (if any) */ |
| struct mali_group *parent_group; |
| |
| struct mali_dlbu_core *dlbu_core; |
| struct mali_bcast_unit *bcast_core; |
| |
| /* Used for working groups which needs to be disabled */ |
| mali_bool disable_requested; |
| |
| /* Used by group to link child groups (for virtual group) */ |
| _mali_osk_list_t group_list; |
| |
| /* Used by executor module in order to link groups of same state */ |
| _mali_osk_list_t executor_list; |
| |
| /* Used by PM domains to link groups of same domain */ |
| _mali_osk_list_t pm_domain_list; |
| |
| _mali_osk_wq_work_t *bottom_half_work_mmu; |
| _mali_osk_wq_work_t *bottom_half_work_gp; |
| _mali_osk_wq_work_t *bottom_half_work_pp; |
| |
| _mali_osk_timer_t *timeout_timer; |
| }; |
| |
| /** @brief Create a new Mali group object |
| * |
| * @return A pointer to a new group object |
| */ |
| struct mali_group *mali_group_create(struct mali_l2_cache_core *core, |
| struct mali_dlbu_core *dlbu, |
| struct mali_bcast_unit *bcast, |
| u32 domain_index); |
| |
| void mali_group_dump_status(struct mali_group *group); |
| |
| void mali_group_delete(struct mali_group *group); |
| |
| _mali_osk_errcode_t mali_group_add_mmu_core(struct mali_group *group, |
| struct mali_mmu_core *mmu_core); |
| void mali_group_remove_mmu_core(struct mali_group *group); |
| |
| _mali_osk_errcode_t mali_group_add_gp_core(struct mali_group *group, |
| struct mali_gp_core *gp_core); |
| void mali_group_remove_gp_core(struct mali_group *group); |
| |
| _mali_osk_errcode_t mali_group_add_pp_core(struct mali_group *group, |
| struct mali_pp_core *pp_core); |
| void mali_group_remove_pp_core(struct mali_group *group); |
| |
| MALI_STATIC_INLINE const char *mali_group_core_description( |
| struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| if (NULL != group->pp_core) { |
| return mali_pp_core_description(group->pp_core); |
| } else { |
| MALI_DEBUG_ASSERT_POINTER(group->gp_core); |
| return mali_gp_core_description(group->gp_core); |
| } |
| } |
| |
| MALI_STATIC_INLINE mali_bool mali_group_is_virtual(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| |
| #if (defined(CONFIG_MALI450) || defined(CONFIG_MALI470)) |
| return (NULL != group->dlbu_core); |
| #else |
| return MALI_FALSE; |
| #endif |
| } |
| |
| /** @brief Check if a group is a part of a virtual group or not |
| */ |
| MALI_STATIC_INLINE mali_bool mali_group_is_in_virtual(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| |
| #if (defined(CONFIG_MALI450) || defined(CONFIG_MALI470)) |
| return (NULL != group->parent_group) ? MALI_TRUE : MALI_FALSE; |
| #else |
| return MALI_FALSE; |
| #endif |
| } |
| |
| /** @brief Reset group |
| * |
| * This function will reset the entire group, |
| * including all the cores present in the group. |
| * |
| * @param group Pointer to the group to reset |
| */ |
| void mali_group_reset(struct mali_group *group); |
| |
| MALI_STATIC_INLINE struct mali_session_data *mali_group_get_session( |
| struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| |
| return group->session; |
| } |
| |
| MALI_STATIC_INLINE void mali_group_clear_session(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| |
| if (NULL != group->session) { |
| mali_mmu_activate_empty_page_directory(group->mmu); |
| group->session = NULL; |
| } |
| } |
| |
| enum mali_group_state mali_group_activate(struct mali_group *group); |
| |
| /* |
| * Change state from ACTIVATION_PENDING to ACTIVE |
| * For virtual group, all childs need to be ACTIVE first |
| */ |
| mali_bool mali_group_set_active(struct mali_group *group); |
| |
| /* |
| * @return MALI_TRUE means one or more domains can now be powered off, |
| * and caller should call either mali_pm_update_async() or |
| * mali_pm_update_sync() in order to do so. |
| */ |
| mali_bool mali_group_deactivate(struct mali_group *group); |
| |
| MALI_STATIC_INLINE enum mali_group_state mali_group_get_state(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return group->state; |
| } |
| |
| MALI_STATIC_INLINE mali_bool mali_group_power_is_on(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| return group->power_is_on; |
| } |
| |
| void mali_group_power_up(struct mali_group *group); |
| void mali_group_power_down(struct mali_group *group); |
| |
| MALI_STATIC_INLINE void mali_group_set_disable_request( |
| struct mali_group *group, mali_bool disable) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| group->disable_requested = disable; |
| |
| /** |
| * When one of child group's disable_requeset is set TRUE, then |
| * the disable_request of parent group should also be set to TRUE. |
| * While, the disable_request of parent group should only be set to FALSE |
| * only when all of its child group's disable_request are set to FALSE. |
| */ |
| if (NULL != group->parent_group && MALI_TRUE == disable) { |
| group->parent_group->disable_requested = disable; |
| } |
| } |
| |
| MALI_STATIC_INLINE mali_bool mali_group_disable_requested( |
| struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return group->disable_requested; |
| } |
| |
| /** @brief Virtual groups */ |
| void mali_group_add_group(struct mali_group *parent, struct mali_group *child); |
| struct mali_group *mali_group_acquire_group(struct mali_group *parent); |
| void mali_group_remove_group(struct mali_group *parent, struct mali_group *child); |
| |
| /** @brief Checks if the group is working. |
| */ |
| MALI_STATIC_INLINE mali_bool mali_group_is_working(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| if (mali_group_is_in_virtual(group)) { |
| struct mali_group *tmp_group = mali_executor_get_virtual_group(); |
| return tmp_group->is_working; |
| } |
| return group->is_working; |
| } |
| |
| MALI_STATIC_INLINE struct mali_gp_job *mali_group_get_running_gp_job(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return group->gp_running_job; |
| } |
| |
| /** @brief Zap MMU TLB on all groups |
| * |
| * Zap TLB on group if \a session is active. |
| */ |
| mali_bool mali_group_zap_session(struct mali_group *group, |
| struct mali_session_data *session); |
| |
| /** @brief Get pointer to GP core object |
| */ |
| MALI_STATIC_INLINE struct mali_gp_core *mali_group_get_gp_core(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| return group->gp_core; |
| } |
| |
| /** @brief Get pointer to PP core object |
| */ |
| MALI_STATIC_INLINE struct mali_pp_core *mali_group_get_pp_core(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| return group->pp_core; |
| } |
| |
| /** @brief Start GP job |
| */ |
| void mali_group_start_gp_job(struct mali_group *group, struct mali_gp_job *job, mali_bool gpu_secure_mode_pre_enabled); |
| |
| void mali_group_start_pp_job(struct mali_group *group, struct mali_pp_job *job, u32 sub_job, mali_bool gpu_secure_mode_pre_enabled); |
| |
| /** @brief Start virtual group Job on a virtual group |
| */ |
| void mali_group_start_job_on_virtual(struct mali_group *group, struct mali_pp_job *job, u32 first_subjob, u32 last_subjob); |
| |
| |
| /** @brief Start a subjob from a particular on a specific PP group |
| */ |
| void mali_group_start_job_on_group(struct mali_group *group, struct mali_pp_job *job, u32 subjob); |
| |
| |
| /** @brief remove all the unused groups in tmp_unused group list, so that the group is in consistent status. |
| */ |
| void mali_group_non_dlbu_job_done_virtual(struct mali_group *group); |
| |
| |
| /** @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); |
| |
| MALI_STATIC_INLINE enum mali_interrupt_result mali_group_get_interrupt_result_gp(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->gp_core); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return mali_gp_get_interrupt_result(group->gp_core); |
| } |
| |
| MALI_STATIC_INLINE enum mali_interrupt_result mali_group_get_interrupt_result_pp(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->pp_core); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return mali_pp_get_interrupt_result(group->pp_core); |
| } |
| |
| MALI_STATIC_INLINE enum mali_interrupt_result mali_group_get_interrupt_result_mmu(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->mmu); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return mali_mmu_get_interrupt_result(group->mmu); |
| } |
| |
| MALI_STATIC_INLINE mali_bool mali_group_gp_is_active(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->gp_core); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return mali_gp_is_active(group->gp_core); |
| } |
| |
| MALI_STATIC_INLINE mali_bool mali_group_pp_is_active(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->pp_core); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return mali_pp_is_active(group->pp_core); |
| } |
| |
| MALI_STATIC_INLINE mali_bool mali_group_has_timed_out(struct mali_group *group) |
| { |
| unsigned long time_cost; |
| struct mali_group *tmp_group = group; |
| |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| |
| /* if the group is in virtual need to use virtual_group's start time */ |
| if (mali_group_is_in_virtual(group)) { |
| tmp_group = mali_executor_get_virtual_group(); |
| } |
| |
| time_cost = _mali_osk_time_tickcount() - tmp_group->start_time; |
| if (_mali_osk_time_mstoticks(mali_max_job_runtime) <= time_cost) { |
| /* |
| * current tick is at or after timeout end time, |
| * so this is a valid timeout |
| */ |
| return MALI_TRUE; |
| } else { |
| /* |
| * Not a valid timeout. A HW interrupt probably beat |
| * us to it, and the timer wasn't properly deleted |
| * (async deletion used due to atomic context). |
| */ |
| return MALI_FALSE; |
| } |
| } |
| |
| MALI_STATIC_INLINE void mali_group_mask_all_interrupts_gp(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->gp_core); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return mali_gp_mask_all_interrupts(group->gp_core); |
| } |
| |
| MALI_STATIC_INLINE void mali_group_mask_all_interrupts_pp(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->pp_core); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return mali_pp_mask_all_interrupts(group->pp_core); |
| } |
| |
| MALI_STATIC_INLINE void mali_group_enable_interrupts_gp( |
| struct mali_group *group, |
| enum mali_interrupt_result exceptions) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->gp_core); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| mali_gp_enable_interrupts(group->gp_core, exceptions); |
| } |
| |
| MALI_STATIC_INLINE void mali_group_schedule_bottom_half_gp(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->gp_core); |
| _mali_osk_wq_schedule_work(group->bottom_half_work_gp); |
| } |
| |
| |
| MALI_STATIC_INLINE void mali_group_schedule_bottom_half_pp(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->pp_core); |
| _mali_osk_wq_schedule_work(group->bottom_half_work_pp); |
| } |
| |
| MALI_STATIC_INLINE void mali_group_schedule_bottom_half_mmu(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT_POINTER(group->mmu); |
| _mali_osk_wq_schedule_work(group->bottom_half_work_mmu); |
| } |
| |
| struct mali_pp_job *mali_group_complete_pp(struct mali_group *group, mali_bool success, u32 *sub_job); |
| |
| struct mali_gp_job *mali_group_complete_gp(struct mali_group *group, mali_bool success); |
| |
| #if defined(CONFIG_MALI400_PROFILING) |
| MALI_STATIC_INLINE void mali_group_oom(struct mali_group *group) |
| { |
| _mali_osk_profiling_add_event(MALI_PROFILING_EVENT_TYPE_SUSPEND | |
| MALI_PROFILING_MAKE_EVENT_CHANNEL_GP(0), |
| 0, 0, 0, 0, 0); |
| } |
| #endif |
| |
| struct mali_group *mali_group_get_glob_group(u32 index); |
| u32 mali_group_get_glob_num_groups(void); |
| |
| u32 mali_group_dump_state(struct mali_group *group, char *buf, u32 size); |
| |
| |
| _mali_osk_errcode_t mali_group_upper_half_mmu(void *data); |
| _mali_osk_errcode_t mali_group_upper_half_gp(void *data); |
| _mali_osk_errcode_t mali_group_upper_half_pp(void *data); |
| |
| MALI_STATIC_INLINE mali_bool mali_group_is_empty(struct mali_group *group) |
| { |
| MALI_DEBUG_ASSERT_POINTER(group); |
| MALI_DEBUG_ASSERT(mali_group_is_virtual(group)); |
| MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD(); |
| return _mali_osk_list_empty(&group->group_list); |
| } |
| |
| #endif /* __MALI_GROUP_H__ */ |