int devfreq_remove_devbw(struct device *dev)
{
struct dev_data *d = dev_get_drvdata(dev);
msm_bus_scale_unregister_client(d->bus_client);
devfreq_remove_device(d->df);
return 0;
}
static int remove(struct platform_device *pdev)
{
struct spdm_data *data = 0;
data = platform_get_drvdata(pdev);
spdm_remove_debugfs(data);
if (data->devfreq)
devfreq_remove_device(data->devfreq);
if (data->profile)
devm_kfree(&pdev->dev, data->profile);
if (data->bus_scale_client_id)
msm_bus_scale_unregister_client(data->bus_scale_client_id);
if (data->config_data.ports)
devm_kfree(&pdev->dev, data->config_data.ports);
devm_kfree(&pdev->dev, data);
platform_set_drvdata(pdev, NULL);
if (spdm_ipc_log_ctxt)
ipc_log_context_destroy(spdm_ipc_log_ctxt);
return 0;
}
int mali_devfreq_remove(void)
{
if (mali_devfreq)
devfreq_remove_device(mali_devfreq);
DEBUG_PRINT_INFO("\n[mali_devfreq]mali_devfreq_remove");
return MALI_TRUE;
}
int __devexit g3_display_remove(struct platform_device *pdev){
struct g3_display_data *data = pdev->dev.platform_data;
unregister_pm_notifier(&data->nb_pm);
devfreq_remove_device(data->devfreq);
kfree(data);
return 0;
}
void nvhost_scale3d_actmon_deinit(struct platform_device *dev)
{
struct nvhost_device_data *pdata = platform_get_drvdata(dev);
if (!power_profile.init)
return;
if (pdata->power_manager)
devfreq_remove_device(pdata->power_manager);
kfree(power_profile.dev_stat->private_data);
kfree(power_profile.dev_stat);
power_profile.init = 0;
}
static int exynos7_devfreq_disp_remove(struct platform_device *pdev)
{
struct devfreq_data_disp *data = platform_get_drvdata(pdev);
devfreq_remove_device(data->devfreq);
pm_qos_remove_request(&min_disp_thermal_qos);
pm_qos_remove_request(&exynos7_disp_qos);
pm_qos_remove_request(&boot_disp_qos);
regulator_put(data->vdd_disp_cam0);
kfree(data);
platform_set_drvdata(pdev, NULL);
return 0;
}
void kbase_devfreq_term(struct kbase_device *kbdev)
{
int err;
dev_dbg(kbdev->dev, "Term Mali devfreq\n");
#ifdef CONFIG_DEVFREQ_THERMAL
devfreq_cooling_unregister(kbdev->devfreq_cooling);
#endif
devfreq_unregister_opp_notifier(kbdev->dev, kbdev->devfreq);
err = devfreq_remove_device(kbdev->devfreq);
if (err)
dev_err(kbdev->dev, "Failed to terminate devfreq (%d)\n", err);
else
kbdev->devfreq = NULL;
}
void nvhost_scale_deinit(struct platform_device *pdev)
{
struct nvhost_device_data *pdata = platform_get_drvdata(pdev);
struct nvhost_device_profile *profile = pdata->power_profile;
if (!profile)
return;
if (pdata->power_manager)
devfreq_remove_device(pdata->power_manager);
if (pdata->actmon_enabled)
device_remove_file(&pdev->dev, &dev_attr_load);
kfree(profile->actmon);
kfree(profile);
pdata->power_profile = NULL;
}
static int exynos5_devfreq_int_remove(struct platform_device *pdev)
{
struct devfreq_data_int *data = platform_get_drvdata(pdev);
devfreq_remove_device(data->devfreq);
pm_qos_remove_request(&min_int_thermal_qos);
pm_qos_remove_request(&exynos5_int_qos);
pm_qos_remove_request(&boot_int_qos);
pm_qos_remove_request(&exynos5_int_bts_qos);
regulator_put(data->vdd_int);
kfree(data);
platform_set_drvdata(pdev, NULL);
return 0;
}
void gk20a_scale_exit(struct platform_device *pdev)
{
struct gk20a_platform *platform = platform_get_drvdata(pdev);
struct gk20a *g = platform->g;
int err;
if (platform->qos_id < PM_QOS_NUM_CLASSES &&
platform->qos_id != PM_QOS_RESERVED &&
platform->postscale) {
pm_qos_remove_notifier(platform->qos_id,
&g->scale_profile->qos_notify_block);
}
if (platform->devfreq_governor) {
err = devfreq_remove_device(g->devfreq);
g->devfreq = NULL;
}
kfree(g->scale_profile);
g->scale_profile = NULL;
}
static int ddr_devfreq_remove(struct platform_device *pdev)
{
struct ddr_devfreq_device *ddev;
struct devfreq_dev_profile *profile;
ddev = platform_get_drvdata(pdev);
if(NULL == ddev)
{
return -1;
}
profile = ddev->devfreq->profile;
opp_free_devfreq_table(&pdev->dev, &profile->freq_table);
devfreq_remove_device(ddev->devfreq);
platform_set_drvdata(pdev, NULL);
clk_put(ddev->get);
clk_put(ddev->set);
kfree(ddev);
return 0;
}
static int exynos5_devfreq_isp_probe(struct platform_device *pdev)
{
int ret = 0;
struct devfreq_data_isp *data;
struct exynos_devfreq_platdata *plat_data;
struct opp *target_opp;
unsigned long freq;
unsigned long volt;
data = kzalloc(sizeof(struct devfreq_data_isp), GFP_KERNEL);
if (data == NULL) {
pr_err("DEVFREQ(ISP) : Failed to allocate private data\n");
ret = -ENOMEM;
goto err_data;
}
exynos5433_devfreq_isp_init(data);
exynos5_devfreq_isp_profile.max_state = data->max_state;
exynos5_devfreq_isp_profile.freq_table = kzalloc(sizeof(int) * data->max_state, GFP_KERNEL);
if (exynos5_devfreq_isp_profile.freq_table == NULL) {
pr_err("DEVFREQ(ISP) : Failed to allocate freq table\n");
ret = -ENOMEM;
goto err_freqtable;
}
ret = exynos5_init_isp_table(&pdev->dev, data);
if (ret)
goto err_inittable;
platform_set_drvdata(pdev, data);
mutex_init(&data->lock);
data->initial_freq = exynos5_devfreq_isp_profile.initial_freq;
data->volt_offset = 0;
isp_dev =
data->dev = &pdev->dev;
data->vdd_isp = regulator_get(NULL, "vdd_disp_cam0");
if (IS_ERR_OR_NULL(data->vdd_isp)) {
pr_err("DEVFREQ(ISP) : Failed to get regulator\n");
goto err_inittable;
}
freq = DEVFREQ_INITIAL_FREQ;
rcu_read_lock();
target_opp = devfreq_recommended_opp(data->dev, &freq, 0);
if (IS_ERR(target_opp)) {
rcu_read_unlock();
dev_err(data->dev, "DEVFREQ(ISP) : Invalid OPP to set voltage");
ret = PTR_ERR(target_opp);
goto err_opp;
}
volt = opp_get_voltage(target_opp);
#ifdef CONFIG_EXYNOS_THERMAL
volt = get_limit_voltage(volt, data->volt_offset);
#endif
rcu_read_unlock();
if (data->isp_set_volt)
data->isp_set_volt(data, volt, volt + VOLT_STEP, false);
data->devfreq = devfreq_add_device(data->dev,
&exynos5_devfreq_isp_profile,
"simple_ondemand",
&exynos5_devfreq_isp_governor_data);
plat_data = data->dev->platform_data;
data->devfreq->min_freq = plat_data->default_qos;
data->devfreq->max_freq = exynos5_devfreq_isp_governor_data.cal_qos_max;
register_reboot_notifier(&exynos5_isp_reboot_notifier);
#ifdef CONFIG_EXYNOS_THERMAL
data->tmu_notifier.notifier_call = exynos5_devfreq_isp_tmu_notifier;
exynos_tmu_add_notifier(&data->tmu_notifier);
#endif
data->use_dvfs = true;
return ret;
err_opp:
regulator_put(data->vdd_isp);
err_inittable:
devfreq_remove_device(data->devfreq);
kfree(exynos5_devfreq_isp_profile.freq_table);
err_freqtable:
kfree(data);
err_data:
return ret;
}
static void kbase_platform_term(struct kbase_device *kbdev)
{
#ifdef CONFIG_PM_DEVFREQ
devfreq_remove_device(kbdev->devfreq);
#endif
}
int g3_display_probe(struct platform_device *pdev){
struct g3_display_data *data;
struct device *dev = &pdev->dev;
int ret = 0;
struct opp *opp;
int i;
data = kzalloc(sizeof(struct g3_display_data), GFP_KERNEL);
if(!data){
dev_err(dev, "cannot_allocate memory.\n");
return -ENOMEM;
}
data->dev = dev;
mutex_init(&data->lock);
/* register opp entries */
for(i=0; i<_LV_END_; i++){
ret = opp_add(dev, g3_display_opp_table[i].freq,
g3_display_opp_table[i].volt);
if(ret){
dev_err(dev, "cannot add opp entries.\n");
goto err_alloc_mem;
}
}
/* find opp entry with init frequency */
opp = opp_find_freq_floor(dev, &g3_display_profile.initial_freq);
if(IS_ERR(opp)){
dev_err(dev, "invalid initial frequency %lu.\n",
g3_display_profile.initial_freq);
ret = PTR_ERR(opp);
goto err_alloc_mem;
}
data->curr_opp = opp;
/* initialize qos */
// TODO
/* register g3_display to devfreq framework */
data->devfreq = devfreq_add_device(dev, &g3_display_profile,
"simple_ondemand", &g3_display_ondemand_data);
if(IS_ERR(data->devfreq)){
ret = PTR_ERR(data->devfreq);
dev_err(dev, "failed to add devfreq: %d\n", ret);
goto err_alloc_mem;
}
devfreq_register_opp_notifier(dev, data->devfreq);
/* register g3_display as client to pm notifier */
memset(&data->nb_pm, 0, sizeof(data->nb_pm));
data->nb_pm.notifier_call = g3_display_pm_notifier_callback;
ret = register_pm_notifier(&data->nb_pm);
if(ret < 0){
dev_err(dev, "failed to get pm notifier: %d\n", ret);
goto err_add_devfreq;
}
platform_set_drvdata(pdev, data);
return 0;
err_add_devfreq:
devfreq_remove_device(data->devfreq);
err_alloc_mem:
kfree(data);
return ret;
}
static int devfreq_clock_remove(struct platform_device *pdev)
{
struct dev_data *d = platform_get_drvdata(pdev);
devfreq_remove_device(d->df);
return 0;
}
static int exynos7_devfreq_disp_probe(struct platform_device *pdev)
{
int ret = 0;
struct devfreq_data_disp *data;
struct exynos_devfreq_platdata *plat_data;
data = kzalloc(sizeof(struct devfreq_data_disp), GFP_KERNEL);
if (data == NULL) {
pr_err("DEVFREQ(DISP) : Failed to allocate private data\n");
ret = -ENOMEM;
goto err_data;
}
ret = exynos7420_devfreq_disp_init(data);
if (ret) {
pr_err("DEVFREQ(DISP) : Failed to intialize data\n");
goto err_freqtable;
}
exynos7_devfreq_disp_profile.max_state = data->max_state;
exynos7_devfreq_disp_profile.freq_table = kzalloc(sizeof(int) * data->max_state, GFP_KERNEL);
if (exynos7_devfreq_disp_profile.freq_table == NULL) {
pr_err("DEVFREQ(DISP) : Failed to allocate freq table\n");
ret = -ENOMEM;
goto err_freqtable;
}
ret = exynos7_init_disp_table(&pdev->dev, data);
if (ret)
goto err_inittable;
platform_set_drvdata(pdev, data);
mutex_init(&data->lock);
data->volt_offset = 0;
data->dev = &pdev->dev;
data->vdd_disp_cam0 = regulator_get(NULL, "vdd_disp_cam0");
if (data->vdd_disp_cam0)
data->old_volt = regulator_get_voltage(data->vdd_disp_cam0);
data->devfreq = devfreq_add_device(data->dev,
&exynos7_devfreq_disp_profile,
"simple_ondemand",
&exynos7_devfreq_disp_governor_data);
plat_data = data->dev->platform_data;
data->devfreq->min_freq = plat_data->default_qos;
data->devfreq->max_freq = exynos7_devfreq_disp_governor_data.cal_qos_max;
data->cur_freq = exynos7_devfreq_disp_profile.initial_freq;
register_reboot_notifier(&exynos7_disp_reboot_notifier);
#ifdef CONFIG_EXYNOS_THERMAL
exynos_tmu_add_notifier(&data->tmu_notifier);
#endif
data->use_dvfs = true;
return ret;
err_inittable:
devfreq_remove_device(data->devfreq);
kfree(exynos7_devfreq_disp_profile.freq_table);
err_freqtable:
kfree(data);
err_data:
return ret;
}
static int exynos5_devfreq_int_probe(struct platform_device *pdev)
{
int ret = 0;
struct devfreq_data_int *data;
struct devfreq_notifier_block *devfreq_nb;
struct exynos_devfreq_platdata *plat_data;
data = kzalloc(sizeof(struct devfreq_data_int), GFP_KERNEL);
if (data == NULL) {
pr_err("DEVFREQ(INT) : Failed to allocate private data\n");
ret = -ENOMEM;
goto err_data;
}
exynos5433_devfreq_int_init(data);
data->initial_freq = exynos5_devfreq_int_profile.initial_freq;
exynos5_devfreq_int_profile.freq_table = kzalloc(sizeof(int) * data->max_state, GFP_KERNEL);
if (exynos5_devfreq_int_profile.freq_table == NULL) {
pr_err("DEVFREQ(INT) : Failed to allocate freq table\n");
ret = -ENOMEM;
goto err_freqtable;
}
ret = exynos5_init_int_table(&pdev->dev, data);
if (ret)
goto err_inittable;
platform_set_drvdata(pdev, data);
mutex_init(&data->lock);
data->target_volt = get_match_volt(ID_INT, DEVFREQ_INITIAL_FREQ);
data->volt_constraint_isp = 0;
data->volt_offset = 0;
int_dev =
data->dev = &pdev->dev;
data->vdd_int = regulator_get(NULL, "vdd_int");
data->devfreq = devfreq_add_device(data->dev,
&exynos5_devfreq_int_profile,
"simple_ondemand",
&exynos5_devfreq_int_governor_data);
devfreq_nb = kzalloc(sizeof(struct devfreq_notifier_block), GFP_KERNEL);
if (devfreq_nb == NULL) {
pr_err("DEVFREQ(INT) : Failed to allocate notifier block\n");
ret = -ENOMEM;
goto err_nb;
}
devfreq_nb->df = data->devfreq;
devfreq_nb->nb.notifier_call = exynos5_devfreq_int_notifier;
exynos5433_devfreq_register(&devfreq_int_exynos);
exynos5433_ppmu_register_notifier(INT, &devfreq_nb->nb);
plat_data = data->dev->platform_data;
data->default_qos = plat_data->default_qos;
data->devfreq->min_freq = plat_data->default_qos;
data->devfreq->max_freq = devfreq_int_opp_list[0].freq;
register_reboot_notifier(&exynos5_int_reboot_notifier);
#ifdef CONFIG_EXYNOS_THERMAL
data->tmu_notifier.notifier_call = exynos5_devfreq_int_tmu_notifier;
exynos_tmu_add_notifier(&data->tmu_notifier);
#endif
data->use_dvfs = true;
return ret;
err_nb:
devfreq_remove_device(data->devfreq);
err_inittable:
kfree(exynos5_devfreq_int_profile.freq_table);
err_freqtable:
kfree(data);
err_data:
return ret;
}
static int mali_devfreq_remove(void)
{
if (mali_devfreq)
devfreq_remove_device(mali_devfreq);
return MALI_TRUE;
}
int kbase_devfreq_init(struct kbase_device *kbdev)
{
struct devfreq_dev_profile *dp;
int err;
dev_dbg(kbdev->dev, "Init Mali devfreq\n");
if (!kbdev->clock)
return -ENODEV;
dp = &kbdev->devfreq_profile;
dp->initial_freq = clk_get_rate(kbdev->clock);
dp->polling_ms = 1000;
dp->target = kbase_devfreq_target;
dp->get_dev_status = kbase_devfreq_status;
dp->get_cur_freq = kbase_devfreq_cur_freq;
dp->exit = kbase_devfreq_exit;
if (kbase_devfreq_init_freq_table(kbdev, dp))
return -EFAULT;
kbdev->devfreq = devfreq_add_device(kbdev->dev, dp,
"simple_ondemand", NULL);
if (IS_ERR_OR_NULL(kbdev->devfreq)) {
kbase_devfreq_term_freq_table(kbdev);
return PTR_ERR(kbdev->devfreq);
}
err = devfreq_register_opp_notifier(kbdev->dev, kbdev->devfreq);
if (err) {
dev_err(kbdev->dev,
"Failed to register OPP notifier (%d)\n", err);
goto opp_notifier_failed;
}
#ifdef CONFIG_DEVFREQ_THERMAL
kbdev->devfreq_cooling = of_devfreq_cooling_register(
kbdev->dev->of_node,
kbdev->devfreq);
if (IS_ERR_OR_NULL(kbdev->devfreq_cooling)) {
err = PTR_ERR(kbdev->devfreq_cooling);
dev_err(kbdev->dev,
"Failed to register cooling device (%d)\n", err);
goto cooling_failed;
}
#ifdef CONFIG_MALI_POWER_ACTOR
err = mali_pa_init(kbdev);
if (err) {
dev_err(kbdev->dev, "Failed to init power actor\n");
goto pa_failed;
}
#endif
#endif
return 0;
#ifdef CONFIG_DEVFREQ_THERMAL
#ifdef CONFIG_MALI_POWER_ACTOR
pa_failed:
devfreq_cooling_unregister(kbdev->devfreq_cooling);
#endif /* CONFIG_MALI_POWER_ACTOR */
cooling_failed:
devfreq_unregister_opp_notifier(kbdev->dev, kbdev->devfreq);
#endif /* CONFIG_DEVFREQ_THERMAL */
opp_notifier_failed:
err = devfreq_remove_device(kbdev->devfreq);
if (err)
dev_err(kbdev->dev, "Failed to terminate devfreq (%d)\n", err);
else
kbdev->devfreq = NULL;
return err;
}
