static int bluetooth_lock_dvfs(void *data, enum rfkill_user_states state)
{
if (HWREV == 0) {
if(!gpio_get_value(GPIO_BT_nRST_REV00))
return 0;
}
else {
if(!gpio_get_value(GPIO_BT_nRST))
return 0;
}
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
s5pv210_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_9);
pr_debug("[BT] dvfs unlock\n");
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
s5pv210_lock_dvfs_high_level(DVFS_LOCK_TOKEN_9, L3);
pr_debug("[BT] dvfs lock to L3\n");
break;
case RFKILL_USER_STATE_HARD_BLOCKED:
s5pv210_lock_dvfs_high_level(DVFS_LOCK_TOKEN_9, L2);
pr_debug("[BT] dvfs lock to L2\n");
break;
default:
pr_err("[BT] bad bluetooth rfkill state %d\n", state);
}
return 0;
}
static PVRSRV_ERROR DisableSGXClocks(void)
{
clk_disable(g3d_clock);
regulator_disable(g3d_pd_regulator);
#ifdef CONFIG_DVFS_LIMIT
s5pv210_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_PVR);
#else
cpufreq_update_policy(current_thread_info()->cpu);
#endif
return PVRSRV_OK;
}
static int mfc_release(struct inode *inode, struct file *file)
{
struct mfc_inst_ctx *mfc_ctx;
int ret;
mutex_lock(&mfc_mutex);
mfc_ctx = (struct mfc_inst_ctx *)file->private_data;
if (mfc_ctx == NULL) {
mfc_err("MFCINST_ERR_INVALID_PARAM\n");
ret = -EIO;
goto out_release;
}
mfc_release_all_buffer(mfc_ctx->mem_inst_no);
mfc_merge_fragment(mfc_ctx->mem_inst_no);
mfc_return_mem_inst_no(mfc_ctx->mem_inst_no);
/* In case of no instance, we should not release codec instance */
if (mfc_ctx->InstNo >= 0) {
clk_enable(mfc_sclk);
mfc_return_inst_no(mfc_ctx->InstNo, mfc_ctx->MfcCodecType);
clk_disable(mfc_sclk);
}
kfree(mfc_ctx);
ret = 0;
if (!mfc_is_running()) {
#ifdef CONFIG_DVFS_LIMIT
s5pv210_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_1);
#endif
/* Turn off mfc power domain regulator */
ret = regulator_disable(mfc_pd_regulator);
if (ret < 0) {
mfc_err("MFC_RET_POWER_DISABLE_FAIL\n");
goto out_release;
}
s5p_release_media_memory_bank(S5P_MDEV_MFC, 0);
s5p_release_media_memory_bank(S5P_MDEV_MFC, 1);
}
out_release:
mutex_unlock(&mfc_mutex);
return ret;
}
static ssize_t dvfslock_ctrl(const char *buf, size_t count)
{
unsigned int ret = -EINVAL;
int dlevel;
int dtime_msec;
//mutex_lock(&dvfslock_ctrl_mutex);
ret = sscanf(buf, "%u", &gdDvfsctrl);
if (ret != 1)
return -EINVAL;
//if (!g_dbs_timer_started) return -EINVAL;
if (gdDvfsctrl == 0) {
if (dvfsctrl_locked) {
s5pv210_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_6);
dvfsctrl_locked = 0;
}
return -EINVAL;
}
if (dvfsctrl_locked)
return 0;
dlevel = gdDvfsctrl & 0xffff0000;
dtime_msec = gdDvfsctrl & 0x0000ffff;
if (dtime_msec < 16)
dtime_msec = 16;
if (dtime_msec == 0)
return -EINVAL;
if (dlevel)
dlevel = L1;
else
dlevel = L0;
printk(KERN_DEBUG "%s : level=%d, time=%d\n", __func__, dlevel, dtime_msec);
s5pv210_lock_dvfs_high_level(DVFS_LOCK_TOKEN_6, dlevel);
dvfsctrl_locked = 1;
schedule_delayed_work(&dvfslock_crtl_unlock_work, msecs_to_jiffies(dtime_msec));
//mutex_unlock(&dvfslock_ctrl_mutex);
return -EINVAL;
}
static int bluetooth_lock_dvfs(void *data, enum rfkill_user_states state)
{
if(!gpio_get_value(GPIO_BT_nRST))
return 0;
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
s5pv210_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_9);
pr_debug("[BT] dvfs unlock\n");
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
s5pv210_lock_dvfs_high_level(DVFS_LOCK_TOKEN_9, OC_LX_OFFSET_LUT[L3]); // [antsvx] don't OC here
pr_debug("[BT] dvfs lock to L3+OC_SHIFT\n");
break;
case RFKILL_USER_STATE_HARD_BLOCKED:
s5pv210_lock_dvfs_high_level(DVFS_LOCK_TOKEN_9, OC_LX_OFFSET_LUT[L2]); // [antsvx] don't OC here
pr_debug("[BT] dvfs lock to L2+OC_SHIFT\n");
break;
default:
pr_err("[BT] bad bluetooth rfkill state %d\n", state);
}
return 0;
}
static int mfc_open(struct inode *inode, struct file *file)
{
struct mfc_inst_ctx *mfc_ctx;
int ret;
mutex_lock(&mfc_mutex);
if (!mfc_is_running()) {
/* Request CMA allocation */
ret = s5p_alloc_media_memory_bank(S5P_MDEV_MFC, 0);
if (ret < 0) {
ret = -ENOMEM;
goto err_open;
}
ret = s5p_alloc_media_memory_bank(S5P_MDEV_MFC, 1);
if (ret < 0) {
ret = -ENOMEM;
goto err_alloc0;
}
/* Turn on mfc power domain regulator */
ret = regulator_enable(mfc_pd_regulator);
if (ret < 0) {
mfc_err("MFC_RET_POWER_ENABLE_FAIL\n");
ret = -EINVAL;
goto err_alloc1;
}
#ifdef CONFIG_DVFS_LIMIT
s5pv210_lock_dvfs_high_level(DVFS_LOCK_TOKEN_1, L2);
#endif
clk_enable(mfc_sclk);
mfc_load_firmware(mfc_fw_info->data, mfc_fw_info->size);
if (mfc_init_hw() != true) {
clk_disable(mfc_sclk);
ret = -ENODEV;
goto err_regulator;
}
clk_disable(mfc_sclk);
}
mfc_ctx = (struct mfc_inst_ctx *)kmalloc(sizeof(struct mfc_inst_ctx), GFP_KERNEL);
if (mfc_ctx == NULL) {
mfc_err("MFCINST_MEMORY_ALLOC_FAIL\n");
ret = -ENOMEM;
goto err_regulator;
}
memset(mfc_ctx, 0, sizeof(struct mfc_inst_ctx));
/* get the inst no allocating some part of memory among reserved memory */
mfc_ctx->mem_inst_no = mfc_get_mem_inst_no();
mfc_ctx->InstNo = -1;
if (mfc_ctx->mem_inst_no < 0) {
mfc_err("MFCINST_INST_NUM_EXCEEDED\n");
ret = -EPERM;
goto err_mem_inst;
}
if (mfc_set_state(mfc_ctx, MFCINST_STATE_OPENED) < 0) {
mfc_err("MFCINST_ERR_STATE_INVALID\n");
ret = -ENODEV;
goto err_set_state;
}
/* Decoder only */
mfc_ctx->extraDPB = MFC_MAX_EXTRA_DPB;
mfc_ctx->FrameType = MFC_RET_FRAME_NOT_SET;
file->private_data = mfc_ctx;
mutex_unlock(&mfc_mutex);
return 0;
err_set_state:
mfc_return_mem_inst_no(mfc_ctx->mem_inst_no);
err_mem_inst:
kfree(mfc_ctx);
err_regulator:
if (!mfc_is_running()) {
#ifdef CONFIG_DVFS_LIMIT
s5pv210_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_1);
#endif
/* Turn off mfc power domain regulator */
ret = regulator_disable(mfc_pd_regulator);
if (ret < 0)
mfc_err("MFC_RET_POWER_DISABLE_FAIL\n");
}
err_alloc1:
if (!mfc_is_running())
s5p_release_media_memory_bank(S5P_MDEV_MFC, 1);
err_alloc0:
if (!mfc_is_running())
s5p_release_media_memory_bank(S5P_MDEV_MFC, 0);
err_open:
mutex_unlock(&mfc_mutex);
return ret;
}
static void do_dvfsunlock_timer(struct work_struct *work)
{
dvfsctrl_locked = 0;
s5pv210_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_6);
}
/*!
******************************************************************************
@Function SysDeinitialise
@Description De-initialises kernel services at 'driver unload' time
@Return PVRSRV_ERROR :
******************************************************************************/
PVRSRV_ERROR SysDeinitialise (SYS_DATA *psSysData)
{
SYS_SPECIFIC_DATA * psSysSpecData;
PVRSRV_ERROR eError;
if (psSysData == IMG_NULL) {
PVR_DPF((PVR_DBG_ERROR, "SysDeinitialise: Called with NULL SYS_DATA pointer. Probably called before."));
return PVRSRV_OK;
}
psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
/* TODO: regulator and clk put. */
#ifdef CONFIG_DVFS_LIMIT
s5pv210_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_PVR);
#else
cpufreq_unregister_notifier(&cpufreq_limit_notifier,
CPUFREQ_POLICY_NOTIFIER);
cpufreq_update_policy(current_thread_info()->cpu);
#endif
#endif
#if defined(SYS_USING_INTERRUPTS)
if (psSysSpecData->ui32SysSpecificData & SYS_SPECIFIC_DATA_ENABLE_LISR)
{
eError = OSUninstallSystemLISR(psSysData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallSystemLISR failed"));
return eError;
}
}
#endif
if (psSysSpecData->ui32SysSpecificData & SYS_SPECIFIC_DATA_ENABLE_MISR)
{
eError = OSUninstallMISR(psSysData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallMISR failed"));
return eError;
}
}
/* de-initialise all services managed devices */
eError = PVRSRVDeinitialiseDevice (gui32SGXDeviceID);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init the device"));
return eError;
}
eError = OSDeInitEnvData(gpsSysData->pvEnvSpecificData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init env structure"));
return eError;
}
SysDeinitialiseCommon(gpsSysData);
gpsSysData = IMG_NULL;
return PVRSRV_OK;
}
