int fimc_is_resourcemgr_probe(struct fimc_is_resourcemgr *resourcemgr,
void *private_data)
{
int ret = 0;
BUG_ON(!resourcemgr);
BUG_ON(!private_data);
resourcemgr->private_data = private_data;
clear_bit(FIMC_IS_RM_COM_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_SS0_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_SS1_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_SS2_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_SS3_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_ISC_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_POWER_ON, &resourcemgr->state);
atomic_set(&resourcemgr->rsccount, 0);
atomic_set(&resourcemgr->resource_sensor0.rsccount, 0);
atomic_set(&resourcemgr->resource_sensor1.rsccount, 0);
atomic_set(&resourcemgr->resource_ischain.rsccount, 0);
atomic_set(&resourcemgr->resource_companion.rsccount, 0);
resourcemgr->hal_version = IS_HAL_VER_1_0;
#if defined(ENABLE_TMU_NOTIFIER)
resourcemgr->tmu_state = ISP_NORMAL;
resourcemgr->limited_fps = 0;
resourcemgr->notifier.notifier_call = fimc_is_tmu_notifier;
resourcemgr->notifier.priority = 0;
ret = exynos_tmu_isp_add_notifier(&resourcemgr->notifier);
if (ret) {
probe_err("exynos_tmu_isp_add_notifier is fail(%d)", ret);
goto p_err;
}
#endif
#ifdef ENABLE_RESERVED_MEM
ret = fimc_is_resourcemgr_initmem(resourcemgr);
if (ret) {
probe_err("fimc_is_resourcemgr_initmem is fail(%d)", ret);
goto p_err;
}
#endif
#ifdef ENABLE_DVFS
/* dvfs controller init */
ret = fimc_is_dvfs_init(resourcemgr);
if (ret) {
probe_err("%s: fimc_is_dvfs_init failed!\n", __func__);
goto p_err;
}
#endif
p_err:
probe_info("[RSC] %s(%d)\n", __func__, ret);
return ret;
}
static ssize_t store_en_dvfs(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
#ifdef ENABLE_DVFS
struct fimc_is_core *core =
(struct fimc_is_core *)platform_get_drvdata(to_platform_device(dev));
struct fimc_is_resourcemgr *resourcemgr;
int i;
BUG_ON(!core);
resourcemgr = &core->resourcemgr;
switch (buf[0]) {
case '0':
sysfs_debug.en_dvfs = false;
/* update dvfs lever to max */
mutex_lock(&resourcemgr->dvfs_ctrl.lock);
for (i = 0; i < FIMC_IS_STREAM_COUNT; i++) {
if (test_bit(FIMC_IS_ISCHAIN_OPEN, &((core->ischain[i]).state)))
fimc_is_set_dvfs(&(core->ischain[i]), FIMC_IS_SN_MAX);
}
fimc_is_dvfs_init(resourcemgr);
resourcemgr->dvfs_ctrl.static_ctrl->cur_scenario_id = FIMC_IS_SN_MAX;
mutex_unlock(&resourcemgr->dvfs_ctrl.lock);
break;
case '1':
/* It can not re-define static scenario */
sysfs_debug.en_dvfs = true;
break;
default:
pr_debug("%s: %c\n", __func__, buf[0]);
break;
}
#endif
return count;
}
int fimc_is_resource_probe(struct fimc_is_resourcemgr *resourcemgr,
void *private_data)
{
int ret = 0;
BUG_ON(!resourcemgr);
BUG_ON(!private_data);
resourcemgr->private_data = private_data;
atomic_set(&resourcemgr->rsccount, 0);
atomic_set(&resourcemgr->rsccount_sensor, 0);
atomic_set(&resourcemgr->rsccount_ischain, 0);
#ifdef ENABLE_DVFS
/* dvfs controller init */
ret = fimc_is_dvfs_init(resourcemgr);
if (ret)
err("%s: fimc_is_dvfs_init failed!\n", __func__);
#endif
info("%s\n", __func__);
return ret;
}
int fimc_is_resource_get(struct fimc_is_resourcemgr *resourcemgr, u32 rsc_type)
{
int ret = 0;
u32 rsccount;
struct fimc_is_resource *resource;
struct fimc_is_core *core;
BUG_ON(!resourcemgr);
BUG_ON(!resourcemgr->private_data);
BUG_ON(rsc_type >= RESOURCE_TYPE_MAX);
resource = GET_RESOURCE(resourcemgr, rsc_type);
core = (struct fimc_is_core *)resourcemgr->private_data;
rsccount = atomic_read(&core->rsccount);
if (rsccount >= 5) {
err("[RSC] Invalid rsccount(%d)", rsccount);
ret = -EMFILE;
goto p_err;
}
if (rsccount == 0) {
#ifdef ENABLE_DVFS
/* dvfs controller init */
ret = fimc_is_dvfs_init(resourcemgr);
if (ret) {
err("%s: fimc_is_dvfs_init failed!\n", __func__);
goto p_err;
}
#endif
}
if (atomic_read(&resource->rsccount) == 0) {
switch (rsc_type) {
case RESOURCE_TYPE_SENSOR0:
break;
case RESOURCE_TYPE_SENSOR1:
break;
case RESOURCE_TYPE_ISCHAIN:
core->debug_cnt = 0;
ret = fimc_is_interface_open(&core->interface);
if (ret) {
err("fimc_is_interface_open is fail(%d)", ret);
goto p_err;
}
ret = fimc_is_ischain_power(&core->ischain[0], 1);
if (ret) {
err("fimc_is_ischain_power is fail (%d)", ret);
goto p_err;
}
/* W/A for a lower version MCUCTL */
fimc_is_interface_reset(&core->interface);
#ifdef ENABLE_CLOCK_GATE
if (sysfs_debug.en_clk_gate &&
sysfs_debug.clk_gate_mode == CLOCK_GATE_MODE_HOST)
fimc_is_clk_gate_init(core);
#endif
break;
default:
err("[RSC] resource type(%d) is invalid", rsc_type);
BUG();
break;
}
}
atomic_inc(&resource->rsccount);
atomic_inc(&core->rsccount);
p_err:
info("[RSC] rsctype : %d, rsccount : %d\n", rsc_type, rsccount);
return ret;
}
int fimc_is_resource_get(struct fimc_is_resourcemgr *resourcemgr, u32 rsc_type)
{
int ret = 0;
u32 rsccount;
struct fimc_is_resource *resource;
struct fimc_is_core *core;
BUG_ON(!resourcemgr);
BUG_ON(!resourcemgr->private_data);
BUG_ON(rsc_type >= RESOURCE_TYPE_MAX);
resource = GET_RESOURCE(resourcemgr, rsc_type);
core = (struct fimc_is_core *)resourcemgr->private_data;
rsccount = atomic_read(&core->rsccount);
if (!core->pdev) {
err("[RSC] pdev is NULL");
ret = -EMFILE;
goto p_err;
}
if (rsccount >= (FIMC_IS_STREAM_COUNT + FIMC_IS_VIDEO_SS3_NUM)) {
err("[RSC] Invalid rsccount(%d)", rsccount);
ret = -EMFILE;
goto p_err;
}
if (rsccount == 0) {
pm_stay_awake(&core->pdev->dev);
resourcemgr->cluster0 = 0;
resourcemgr->cluster1 = 0;
#ifdef ENABLE_DVFS
/* dvfs controller init */
ret = fimc_is_dvfs_init(resourcemgr);
if (ret) {
err("%s: fimc_is_dvfs_init failed!\n", __func__);
goto p_err;
}
#endif
}
if (atomic_read(&resource->rsccount) == 0) {
switch (rsc_type) {
case RESOURCE_TYPE_COMPANION:
#if defined(CONFIG_PM_RUNTIME)
pm_runtime_get_sync(&resource->pdev->dev);
#else
fimc_is_companion_runtime_resume(&resource->pdev->dev);
#endif
set_bit(FIMC_IS_RM_COM_POWER_ON, &resourcemgr->state);
break;
case RESOURCE_TYPE_SENSOR0:
#ifdef CONFIG_PM_RUNTIME
pm_runtime_get_sync(&resource->pdev->dev);
#else
fimc_is_sensor_runtime_resume(&resource->pdev->dev);
#endif
set_bit(FIMC_IS_RM_SS0_POWER_ON, &resourcemgr->state);
break;
case RESOURCE_TYPE_SENSOR1:
#ifdef CONFIG_PM_RUNTIME
pm_runtime_get_sync(&resource->pdev->dev);
#else
fimc_is_sensor_runtime_resume(&resource->pdev->dev);
#endif
set_bit(FIMC_IS_RM_SS1_POWER_ON, &resourcemgr->state);
break;
case RESOURCE_TYPE_ISCHAIN:
if (test_bit(FIMC_IS_RM_POWER_ON, &resourcemgr->state)) {
err("all resource is not power off(%lX)", resourcemgr->state);
ret = -EINVAL;
goto p_err;
}
#ifndef ENABLE_RESERVED_MEM
ret = fimc_is_resourcemgr_initmem(resourcemgr);
if (ret) {
err("fimc_is_resourcemgr_initmem is fail(%d)\n", ret);
goto p_err;
}
#endif
ret = fimc_is_debug_open(&resourcemgr->minfo);
if (ret) {
err("fimc_is_debug_open is fail(%d)", ret);
goto p_err;
}
ret = fimc_is_interface_open(&core->interface);
if (ret) {
err("fimc_is_interface_open is fail(%d)", ret);
goto p_err;
}
ret = fimc_is_ischain_power(&core->ischain[0], 1);
if (ret) {
err("fimc_is_ischain_power is fail(%d)", ret);
fimc_is_ischain_power(&core->ischain[0], 0);
goto p_err;
}
/* W/A for a lower version MCUCTL */
fimc_is_interface_reset(&core->interface);
#ifdef ENABLE_CLOCK_GATE
if (sysfs_debug.en_clk_gate &&
sysfs_debug.clk_gate_mode == CLOCK_GATE_MODE_HOST)
fimc_is_clk_gate_init(core);
#endif
set_bit(FIMC_IS_RM_ISC_POWER_ON, &resourcemgr->state);
set_bit(FIMC_IS_RM_POWER_ON, &resourcemgr->state);
break;
default:
err("[RSC] resource type(%d) is invalid", rsc_type);
BUG();
break;
}
}
atomic_inc(&resource->rsccount);
atomic_inc(&core->rsccount);
p_err:
info("[RSC] rsctype : %d, rsccount : %d\n", rsc_type, rsccount + 1);
return ret;
}
