static int clk_prcmu_opp_prepare(struct clk_hw *hw)
{
int err;
struct clk_prcmu *clk = to_clk_prcmu(hw);
if (!clk->opp_requested) {
err = prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP,
(char *)__clk_get_name(hw->clk),
100);
if (err) {
pr_err("clk_prcmu: %s fail req APE OPP for %s.\n",
__func__, __clk_get_name(hw->clk));
return err;
}
clk->opp_requested = 1;
}
err = prcmu_request_clock(clk->cg_sel, true);
if (err) {
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP,
(char *)__clk_get_name(hw->clk));
clk->opp_requested = 0;
return err;
}
clk->is_prepared = 1;
return 0;
}
static void ws2401_dpi_mcde_panel_early_suspend(
struct early_suspend *earlysuspend)
{
struct ws2401_dpi *lcd = container_of(earlysuspend,
struct ws2401_dpi,
earlysuspend);
pm_message_t dummy;
if (lcd->pd->bl_ctrl)
lcd->bd_enable = FALSE;
#ifdef ESD_OPERATION
if (lcd->esd_enable) {
lcd->esd_enable = 0;
set_irq_type(GPIO_TO_IRQ(lcd->esd_port), IRQF_TRIGGER_NONE);
disable_irq_nosync(GPIO_TO_IRQ(lcd->esd_port));
if (!list_empty(&(lcd->esd_work.entry))) {
cancel_work_sync(&(lcd->esd_work));
pr_info("%s cancel_work_sync", __func__);
}
pr_info("%s change lcd->esd_enable :%d", __func__,
lcd->esd_enable);
}
#endif
ws2401_dpi_mcde_panel_suspend(lcd->mdd, dummy);
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP,
"codina_lcd_dpi");
}
static void s6d27a1_release_opp(struct s6d27a1_dpi *lcd)
{
if (lcd->opp_is_requested) {
prcmu_qos_remove_requirement(PRCMU_QOS_DDR_OPP, LCD_DRIVER_NAME_S6D27A1);
lcd->opp_is_requested = false;
dev_dbg(lcd->dev, "DDR OPP removed\n");
}
}
_mali_osk_errcode_t mali_platform_deinit()
{
destroy_workqueue(mali_utilization_workqueue);
regulator_put(regulator);
clk_put(clk_sga);
#if CONFIG_HAS_WAKELOCK
wake_lock_destroy(&wakelock);
#endif
kobject_put(mali_kobject);
is_running = false;
mali_last_utilization = 0;
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "mali");
prcmu_qos_remove_requirement(PRCMU_QOS_DDR_OPP, "mali");
is_initialized = false;
MALI_DEBUG_PRINT(2, ("SGA terminated.\n"));
MALI_SUCCESS;
}
static void ws2401_work_opp_timeout_function(struct work_struct *work)
{
struct ws2401_lcd *lcd = container_of(work,
struct ws2401_lcd,
opp_timeout_work.work);
dev_vdbg(&lcd->mdd->dev, "%s: display update timeout\n",
__func__);
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, (char *)"ws2401");
lcd->opp_is_requested = false;
}
static int __init performance_register(void)
{
int ret_mmc;
int ret_wlan;
int ret;
#ifdef CONFIG_MMC_BLOCK
ret_mmc = prcmu_qos_add_requirement(PRCMU_QOS_ARM_KHZ, "mmc",
PRCMU_QOS_DEFAULT_VALUE);
if (!ret_mmc)
ret_mmc = prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "mmc",
PRCMU_QOS_DEFAULT_VALUE);
if (!ret_mmc)
ret_mmc = prcmu_qos_add_requirement(PRCMU_QOS_DDR_OPP, "mmc",
PRCMU_QOS_DEFAULT_VALUE);
if (ret_mmc) {
pr_err("%s: Failed to add PRCMU QoS req for mmc\n", __func__);
prcmu_qos_remove_requirement(PRCMU_QOS_ARM_KHZ, "mmc");
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "mmc");
prcmu_qos_remove_requirement(PRCMU_QOS_DDR_OPP, "mmc");
} else {
INIT_DELAYED_WORK_DEFERRABLE(&work_mmc, mmc_load);
schedule_delayed_work(&work_mmc,
msecs_to_jiffies(perf_mmc_probe_delay));
}
#endif
ret_wlan = prcmu_qos_add_requirement(PRCMU_QOS_ARM_KHZ, "wlan",
PRCMU_QOS_DEFAULT_VALUE);
if (!ret_wlan)
ret_wlan = prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "wlan",
PRCMU_QOS_DEFAULT_VALUE);
if (!ret_wlan)
ret_wlan = prcmu_qos_add_requirement(PRCMU_QOS_DDR_OPP, "wlan",
PRCMU_QOS_DEFAULT_VALUE);
if (ret_wlan) {
pr_err("%s: Failed to add PRCMU QoS req for wlan\n", __func__);
prcmu_qos_remove_requirement(PRCMU_QOS_ARM_KHZ, "wlan");
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "wlan");
prcmu_qos_remove_requirement(PRCMU_QOS_DDR_OPP, "wlan");
} else {
INIT_DELAYED_WORK_DEFERRABLE(&work_wlan_workaround, wlan_load);
schedule_delayed_work_on(0, &work_wlan_workaround,
msecs_to_jiffies(wlan_probe_delay));
}
performance_kobject = kobject_create_and_add("performance", kernel_kobj);
if (!performance_kobject) {
pr_err("[Performance] Failed to create kobject interface\n");
}
ret = sysfs_create_group(performance_kobject, &performance_interface_group);
if (ret) {
kobject_put(performance_kobject);
}
/* Only return one error code */
return ret_mmc ? ret_mmc : (ret_wlan ? ret_wlan : ret);
}
static int ux500_msp_drv_remove(struct platform_device *pdev)
{
struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(&pdev->dev);
ux500_pcm_unregister_platform(pdev);
snd_soc_unregister_component(&pdev->dev);
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "ux500_msp_i2s");
ux500_msp_i2s_cleanup_msp(pdev, drvdata->msp);
return 0;
}
static int request_ape_opp100(bool enable)
{
static unsigned int requests;
if (enable) {
if (0 == requests++) {
return prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP,
"clock", 100);
}
} else if (1 == requests--) {
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "clock");
}
return 0;
}
/* Rationale behind the values for:
* MALI_HIGH_LEVEL_UTILIZATION_LIMIT and MALI_LOW_LEVEL_UTILIZATION_LIMIT
* When operating at half clock frequency a faster clock is requested when
* reaching 75% utilization. When operating at full clock frequency a slower
* clock is requested when reaching 25% utilization. There is a margin of 25%
* at the high range of the slow clock to avoid complete saturation of the
* hardware and there is some overlap to avoid an oscillating situation where
* the clock goes back and forth from high to low.
*
* Utilization on full speed clock
* 0 64 128 192 255
* |---------------|---------------|---------------|---------------|
* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* | ^
* V |
* XXXXXXXXXXXXXXXXXXXXXXXXX
* 0 64 128 192 255
* |-------|-------|-------|-------|
* Utilization on half speed clock
*/
void mali_utilization_function(struct work_struct *ptr)
{
/*By default, platform start with 50% APE OPP and 25% DDR OPP*/
static u32 has_requested_low = 1;
if (last_utilization > MALI_LOW_TO_HIGH_LEVEL_UTILIZATION_LIMIT) {
if (has_requested_low) {
MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u SIGNAL_HIGH\n", last_utilization));
/*Request 100% APE_OPP.*/
if (prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "mali", 100)) {
MALI_DEBUG_PRINT(2, ("MALI 100% APE_OPP failed\n"));
return;
}
/*
* Since the utilization values will be reported higher
* if DDR_OPP is lowered, we also request 100% DDR_OPP.
*/
if (prcmu_qos_add_requirement(PRCMU_QOS_DDR_OPP, "mali", 100)) {
MALI_DEBUG_PRINT(2, ("MALI 100% DDR_OPP failed\n"));
return;
}
has_requested_low = 0;
}
} else {
if (last_utilization < MALI_HIGH_TO_LOW_LEVEL_UTILIZATION_LIMIT) {
if (!has_requested_low) {
/*Remove APE_OPP and DDR_OPP requests*/
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "mali");
prcmu_qos_remove_requirement(PRCMU_QOS_DDR_OPP, "mali");
MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u SIGNAL_LOW\n", last_utilization));
has_requested_low = 1;
}
}
}
MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u\n", last_utilization));
}
static int __devexit ux500_msp_drv_remove(struct platform_device *pdev)
{
struct ux500_msp_i2s_drvdata *drvdata = dev_get_drvdata(&pdev->dev);
snd_soc_unregister_dais(&pdev->dev, ARRAY_SIZE(ux500_msp_dai_drv));
devm_regulator_put(drvdata->reg_vape);
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "ux500_msp_i2s");
clk_put(drvdata->clk);
ux500_msp_i2s_cleanup_msp(pdev, drvdata->msp);
return 0;
}
static void clk_prcmu_opp_unprepare(struct clk_hw *hw)
{
struct clk_prcmu *clk = to_clk_prcmu(hw);
if (prcmu_request_clock(clk->cg_sel, false)) {
pr_err("clk_prcmu: %s failed to disable %s.\n", __func__,
__clk_get_name(hw->clk));
return;
}
if (clk->opp_requested) {
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP,
(char *)__clk_get_name(hw->clk));
clk->opp_requested = 0;
}
clk->is_prepared = 0;
}
static int ws2401_platform_disable(struct mcde_display_device *ddev)
{
int ret = 0;
struct ws2401_lcd *lcd = NULL;
lcd = dev_get_drvdata(&ddev->dev);
if (!lcd->pd->no_bl_ctrl) {
/* switch backlight off */
gpio_set_value(lcd->pd->bl_en_gpio, 0);
}
/* Remove OPP request */
if (ddev->port->mode == MCDE_PORTMODE_CMD)
cancel_delayed_work(&lcd->opp_timeout_work);
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, (char *)"ws2401");
lcd->opp_is_requested = false;
if (lcd->pd->power_on_gpio)
gpio_set_value(lcd->pd->power_on_gpio, !lcd->pd->power_on_high);
return ret;
}
int mmio_cam_desinitboard(
struct mmio_info *info)
{
int err = 0;
dev_dbg(info->dev, "%s\n", __func__);
err = info->pdata->config_i2c_pins(info->pdata, MMIO_DEACTIVATE_I2C);
if (err) {
dev_err(info->dev,
"Failed to disable I2C: %d\n",
err);
goto out;
}
info->pdata->platform_exit(info->pdata);
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP,
(char *)info->misc_dev.name);
out:
return err;
}
