void _mali_osk_pm_dev_enable(void)
{
_mali_osk_atomic_init(&mali_pm_ref_count, 0);
_mali_osk_atomic_init(&mali_suspend_called, 0);
if (NULL == pm_timer)
{
pm_timer = _mali_osk_timer_init();
}
if (NULL != pm_timer)
{
_mali_osk_timer_setcallback(pm_timer, _mali_pm_callback, NULL);
}
pm_lock = _mali_osk_mutex_init(_MALI_OSK_LOCKFLAG_ORDERED, 0);
#if MALI_LICENSE_IS_GPL
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
mali_pm_wq = alloc_workqueue("mali_pm", WQ_UNBOUND, 0);
#else
mali_pm_wq = create_workqueue("mali_pm");
#endif
if(NULL == mali_pm_wq)
{
MALI_PRINT_ERROR(("Unable to create Mali pm workqueue\n"));
}
#endif
INIT_WORK( &mali_pm_wq_work_handle, mali_bottom_half_pm );
}
_mali_osk_errcode_t mali_pm_initialize(void)
{
_mali_osk_errcode_t err;
struct mali_pmu_core *pmu;
pm_lock_state = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_PM_STATE);
if (NULL == pm_lock_state) {
mali_pm_terminate();
return _MALI_OSK_ERR_FAULT;
}
pm_lock_exec = _mali_osk_mutex_init(_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_PM_STATE);
if (NULL == pm_lock_exec) {
mali_pm_terminate();
return _MALI_OSK_ERR_FAULT;
}
pm_work = _mali_osk_wq_create_work(mali_pm_update_work, NULL);
if (NULL == pm_work) {
mali_pm_terminate();
return _MALI_OSK_ERR_FAULT;
}
pmu = mali_pmu_get_global_pmu_core();
if (NULL != pmu) {
/*
* We have a Mali PMU, set the correct domain
* configuration (default or custom)
*/
u32 registered_cores_mask;
mali_pm_set_pmu_domain_config();
registered_cores_mask = mali_pm_get_registered_cores_mask();
mali_pmu_set_registered_cores_mask(pmu, registered_cores_mask);
MALI_DEBUG_ASSERT(0 == pd_mask_wanted);
}
/* Create all power domains needed (at least one dummy domain) */
err = mali_pm_create_pm_domains();
if (_MALI_OSK_ERR_OK != err) {
mali_pm_terminate();
return err;
}
// add by MTK
MTK_mali_osk_pm_dev_enable();
return _MALI_OSK_ERR_OK;
}
void MTK_mali_osk_pm_dev_enable(void)
{
_mali_osk_atomic_init(&mtk_mali_pm_ref_count, 0);
_mali_osk_atomic_init(&mtk_mali_suspend_called, 0);
mtk_pm_lock = _mali_osk_mutex_init(_MALI_OSK_LOCKFLAG_ORDERED, 0);
mtk_mali_pm_wq = alloc_workqueue("mtk_mali_pm", WQ_UNBOUND, 0);
mtk_mali_pm_wq2 = alloc_workqueue("mtk_mali_pm2", WQ_UNBOUND, 0);
if(NULL == mtk_mali_pm_wq || NULL == mtk_mali_pm_wq2)
{
MALI_PRINT_ERROR(("Unable to create Mali pm workqueue\n"));
}
INIT_WORK(&mtk_mali_pm_wq_work_handle, MTK_mali_bottom_half_pm_suspend );
INIT_WORK(&mtk_mali_pm_wq_work_handle2, MTK_mali_bottom_half_pm_resume);
}
_mali_osk_errcode_t mali_platform_init(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct mali_platform_drv_data *mali_drv_data;
int ret;
mali_drv_data = devm_kzalloc(dev, sizeof(*mali_drv_data), GFP_KERNEL);
if (!mali_drv_data) {
dev_err(dev, "no mem\n");
return _MALI_OSK_ERR_NOMEM;
}
dev_set_drvdata(dev, mali_drv_data);
mali_drv_data->dev = dev;
mali_dev = dev;
ret = mali_clock_init(dev);
if (ret)
goto err_init;
ret = mali_dvfs_init(dev);
if (ret)
goto err_init;
ret = mali_create_sysfs(dev);
if (ret)
goto term_clk;
mali_drv_data->clockSetlock = _mali_osk_mutex_init(_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_UTILIZATION);
mali_core_scaling_enable = 1;
return 0;
term_clk:
mali_clock_term(dev);
err_init:
return _MALI_OSK_ERR_FAULT;
}
_mali_osk_errcode_t mali_memory_session_begin(struct mali_session_data *session_data)
{
MALI_DEBUG_PRINT(5, ("Memory session begin\n"));
/* Create descriptor mapping table */
session_data->descriptor_mapping = mali_descriptor_mapping_create(MALI_MEM_DESCRIPTORS_INIT, MALI_MEM_DESCRIPTORS_MAX);
if (NULL == session_data->descriptor_mapping) {
MALI_ERROR(_MALI_OSK_ERR_NOMEM);
}
session_data->memory_lock = _mali_osk_mutex_init(_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_MEM_SESSION);
if (NULL == session_data->memory_lock) {
mali_descriptor_mapping_destroy(session_data->descriptor_mapping);
_mali_osk_free(session_data);
MALI_ERROR(_MALI_OSK_ERR_FAULT);
}
MALI_DEBUG_PRINT(5, ("MMU session begin: success\n"));
MALI_SUCCESS;
}
_mali_osk_errcode_t _mali_internal_profiling_init(mali_bool auto_start)
{
profile_entries = NULL;
profile_mask = 0;
_mali_osk_atomic_init(&profile_insert_index, 0);
lock = _mali_osk_mutex_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_PROFILING);
if (NULL == lock) {
return _MALI_OSK_ERR_FAULT;
}
prof_state = MALI_PROFILING_STATE_IDLE;
if (MALI_TRUE == auto_start) {
u32 limit = MALI_PROFILING_MAX_BUFFER_ENTRIES; /* Use maximum buffer size */
mali_set_user_setting(_MALI_UK_USER_SETTING_SW_EVENTS_ENABLE, MALI_TRUE);
if (_MALI_OSK_ERR_OK != _mali_internal_profiling_start(&limit)) {
return _MALI_OSK_ERR_FAULT;
}
}
return _MALI_OSK_ERR_OK;
}
static mali_bool init_mali_clock(void)
{
mali_bool ret = MALI_TRUE;
gpu_power_state = 0;
if (mali_clock != 0)
return ret; // already initialized
mali_dvfs_lock = _mali_osk_mutex_init(0, 0);
if (mali_dvfs_lock == NULL)
return _MALI_OSK_ERR_FAULT;
if (mali_clk_set_rate(mali_gpu_clk, GPU_MHZ) == MALI_FALSE)
{
ret = MALI_FALSE;
goto err_clock_get;
}
MALI_PRINT(("init_mali_clock mali_clock %p \n", mali_clock));
#ifdef CONFIG_REGULATOR
#ifdef USING_MALI_PMM
g3d_regulator = regulator_get(&mali_gpu_device.dev, "vdd_g3d");
#else
g3d_regulator = regulator_get(NULL, "vdd_g3d");
#endif
if (IS_ERR(g3d_regulator))
{
MALI_PRINT( ("MALI Error : failed to get vdd_g3d\n"));
ret = MALI_FALSE;
goto err_regulator;
}
regulator_enable(g3d_regulator);
MALI_DEBUG_PRINT(1, ("= regulator_enable -> use cnt: %d \n",mali_regulator_get_usecount()));
mali_regulator_set_voltage(mali_gpu_vol, mali_gpu_vol);
#endif
MALI_DEBUG_PRINT(2, ("MALI Clock is set at mali driver\n"));
MALI_DEBUG_PRINT(3,("::clk_put:: %s mali_parent_clock - normal\n", __FUNCTION__));
MALI_DEBUG_PRINT(3,("::clk_put:: %s mpll_clock - normal\n", __FUNCTION__));
mali_clk_put(MALI_FALSE);
return MALI_TRUE;
#ifdef CONFIG_REGULATOR
err_regulator:
regulator_put(g3d_regulator);
#endif
err_clock_get:
mali_clk_put(MALI_TRUE);
return ret;
}