Merge "msm_rmnet: Fix potential memory corruption"
diff --git a/drivers/crypto/msm/qcrypto.c b/drivers/crypto/msm/qcrypto.c
index b8975aa..276bf53 100644
--- a/drivers/crypto/msm/qcrypto.c
+++ b/drivers/crypto/msm/qcrypto.c
@@ -1692,12 +1692,12 @@
rctx->orig_src = req->src;
rctx->orig_dst = req->dst;
- if ((MAX_ALIGN_SIZE*2 > ULONG_MAX - req->assoclen) ||
- ((MAX_ALIGN_SIZE*2 + req->assoclen) >
- ULONG_MAX - qreq.authsize) ||
- ((MAX_ALIGN_SIZE*2 + req->assoclen +
+ if ((MAX_ALIGN_SIZE*2 > UINT_MAX - qreq.assoclen) ||
+ ((MAX_ALIGN_SIZE*2 + qreq.assoclen) >
+ UINT_MAX - qreq.authsize) ||
+ ((MAX_ALIGN_SIZE*2 + qreq.assoclen +
qreq.authsize) >
- ULONG_MAX - req->cryptlen)) {
+ UINT_MAX - req->cryptlen)) {
pr_err("Integer overflow on aead req length.\n");
return -EINVAL;
}
diff --git a/drivers/net/wireless/wcnss/wcnss_wlan.c b/drivers/net/wireless/wcnss/wcnss_wlan.c
index db34307..90cf441 100644
--- a/drivers/net/wireless/wcnss/wcnss_wlan.c
+++ b/drivers/net/wireless/wcnss/wcnss_wlan.c
@@ -35,6 +35,7 @@
#include <linux/rwsem.h>
#include <linux/mfd/pm8xxx/misc.h>
#include <linux/qpnp/qpnp-adc.h>
+#include <linux/pm_qos.h>
#include <mach/board.h>
#include <mach/msm_smd.h>
@@ -51,6 +52,10 @@
#define VERSION "1.01"
#define WCNSS_PIL_DEVICE "wcnss"
+#define WCNSS_DISABLE_PC_LATENCY 100
+#define WCNSS_ENABLE_PC_LATENCY PM_QOS_DEFAULT_VALUE
+#define WCNSS_PM_QOS_TIMEOUT 15000
+
/* module params */
#define WCNSS_CONFIG_UNSPECIFIED (-1)
#define UINT32_MAX (0xFFFFFFFFU)
@@ -426,6 +431,9 @@
u16 unsafe_ch_list[WCNSS_MAX_CH_NUM];
void *wcnss_notif_hdle;
u8 is_shutdown;
+ struct pm_qos_request wcnss_pm_qos_request;
+ int pc_disabled;
+ struct delayed_work wcnss_pm_qos_del_req;
} *penv = NULL;
static ssize_t wcnss_wlan_macaddr_store(struct device *dev,
@@ -970,6 +978,46 @@
device_remove_file(dev, &dev_attr_wcnss_mac_addr);
}
}
+
+static void wcnss_pm_qos_add_request(void)
+{
+ pr_info("%s: add request", __func__);
+ pm_qos_add_request(&penv->wcnss_pm_qos_request, PM_QOS_CPU_DMA_LATENCY,
+ PM_QOS_DEFAULT_VALUE);
+}
+
+static void wcnss_pm_qos_remove_request(void)
+{
+ pr_info("%s: remove request", __func__);
+ pm_qos_remove_request(&penv->wcnss_pm_qos_request);
+}
+
+void wcnss_pm_qos_update_request(int val)
+{
+ pr_info("%s: update request %d", __func__, val);
+ pm_qos_update_request(&penv->wcnss_pm_qos_request, val);
+}
+
+void wcnss_disable_pc_remove_req(void)
+{
+ if (penv->pc_disabled) {
+ wcnss_pm_qos_update_request(WCNSS_ENABLE_PC_LATENCY);
+ wcnss_pm_qos_remove_request();
+ wcnss_allow_suspend();
+ penv->pc_disabled = 0;
+ }
+}
+
+void wcnss_disable_pc_add_req(void)
+{
+ if (!penv->pc_disabled) {
+ wcnss_pm_qos_add_request();
+ wcnss_prevent_suspend();
+ wcnss_pm_qos_update_request(WCNSS_DISABLE_PC_LATENCY);
+ penv->pc_disabled = 1;
+ }
+}
+
static void wcnss_smd_notify_event(void *data, unsigned int event)
{
int len = 0;
@@ -993,6 +1041,8 @@
WCNSS_CTRL_CHANNEL);
schedule_work(&penv->wcnssctrl_version_work);
schedule_work(&penv->wcnss_pm_config_work);
+ __cancel_delayed_work(&penv->wcnss_pm_qos_del_req);
+ schedule_delayed_work(&penv->wcnss_pm_qos_del_req, 0);
break;
@@ -2028,6 +2078,11 @@
return;
}
+static void wcnss_pm_qos_enable_pc(struct work_struct *worker)
+{
+ wcnss_disable_pc_remove_req();
+ return;
+}
static void wcnss_caldata_dnld(const void *cal_data,
unsigned int cal_data_size, bool msg_to_follow)
@@ -2342,8 +2397,11 @@
INIT_WORK(&penv->wcnssctrl_version_work, wcnss_send_version_req);
INIT_WORK(&penv->wcnss_pm_config_work, wcnss_send_pm_config);
INIT_WORK(&penv->wcnssctrl_nvbin_dnld_work, wcnss_nvbin_dnld_main);
+ INIT_DELAYED_WORK(&penv->wcnss_pm_qos_del_req, wcnss_pm_qos_enable_pc);
wake_lock_init(&penv->wcnss_wake_lock, WAKE_LOCK_SUSPEND, "wcnss");
+ /* Add pm_qos request to disable power collapse for DDR */
+ wcnss_disable_pc_add_req();
if (wcnss_hardware_type() == WCNSS_PRONTO_HW) {
size = 0x3000;
@@ -2467,6 +2525,7 @@
if (IS_ERR(penv->pil)) {
dev_err(&pdev->dev, "Peripheral Loader failed on WCNSS.\n");
ret = PTR_ERR(penv->pil);
+ wcnss_disable_pc_add_req();
wcnss_pronto_log_debug_regs();
}
} while (pil_retry++ < WCNSS_MAX_PIL_RETRY && IS_ERR(penv->pil));
@@ -2479,6 +2538,8 @@
penv->pil = NULL;
goto fail_pil;
}
+ /* Remove pm_qos request */
+ wcnss_disable_pc_remove_req();
return 0;
@@ -2531,6 +2592,7 @@
else
wcnss_gpios_config(penv->gpios_5wire, false);
fail_gpio_res:
+ wcnss_disable_pc_remove_req();
penv = NULL;
return ret;
}
@@ -2657,14 +2719,18 @@
static int wcnss_notif_cb(struct notifier_block *this, unsigned long code,
void *ss_handle)
{
- pr_debug("%s: wcnss notification event: %lu\n", __func__, code);
+ pr_info("%s: wcnss notification event: %lu\n", __func__, code);
- if (SUBSYS_POWERUP_FAILURE == code)
- wcnss_pronto_log_debug_regs();
- else if (SUBSYS_BEFORE_SHUTDOWN == code)
- penv->is_shutdown = 1;
- else if (SUBSYS_AFTER_POWERUP == code)
- penv->is_shutdown = 0;
+ if (code == SUBSYS_BEFORE_SHUTDOWN) {
+ penv->is_shutdown = 1;
+ wcnss_disable_pc_add_req();
+ schedule_delayed_work(&penv->wcnss_pm_qos_del_req,
+ msecs_to_jiffies(WCNSS_PM_QOS_TIMEOUT));
+ } else if (code == SUBSYS_POWERUP_FAILURE) {
+ wcnss_pronto_log_debug_regs();
+ wcnss_disable_pc_remove_req();
+ } else if (SUBSYS_AFTER_POWERUP == code)
+ penv->is_shutdown = 0;
return NOTIFY_DONE;
}
diff --git a/drivers/video/msm/mdss/mdss_dsi_panel.c b/drivers/video/msm/mdss/mdss_dsi_panel.c
index a72779d..6e2a7f5 100644
--- a/drivers/video/msm/mdss/mdss_dsi_panel.c
+++ b/drivers/video/msm/mdss/mdss_dsi_panel.c
@@ -41,6 +41,7 @@
{
int ret;
u32 duty;
+ u32 period_ns;
if (ctrl->pwm_bl == NULL) {
pr_err("%s: no PWM\n", __func__);
@@ -69,10 +70,23 @@
ctrl->pwm_enabled = 0;
}
- ret = pwm_config_us(ctrl->pwm_bl, duty, ctrl->pwm_period);
- if (ret) {
- pr_err("%s: pwm_config_us() failed err=%d.\n", __func__, ret);
- return;
+ if (ctrl->pwm_period >= USEC_PER_SEC) {
+ ret = pwm_config_us(ctrl->pwm_bl, duty, ctrl->pwm_period);
+ if (ret) {
+ pr_err("%s: pwm_config_us() failed err=%d.\n",
+ __func__, ret);
+ return;
+ }
+ } else {
+ period_ns = ctrl->pwm_period * NSEC_PER_USEC;
+ ret = pwm_config(ctrl->pwm_bl,
+ level * period_ns / ctrl->bklt_max,
+ period_ns);
+ if (ret) {
+ pr_err("%s: pwm_config() failed err=%d.\n",
+ __func__, ret);
+ return;
+ }
}
ret = pwm_enable(ctrl->pwm_bl);
diff --git a/drivers/video/msm/mdss/mdss_fb.c b/drivers/video/msm/mdss/mdss_fb.c
index 95d403b..bf91a29 100644
--- a/drivers/video/msm/mdss/mdss_fb.c
+++ b/drivers/video/msm/mdss/mdss_fb.c
@@ -884,6 +884,8 @@
struct mdss_panel_data *pdata;
int (*update_ad_input)(struct msm_fb_data_type *mfd);
u32 temp = bkl_lvl;
+ int ret = -EINVAL;
+ bool is_bl_changed = (bkl_lvl != mfd->bl_level);
if (((!mfd->panel_power_on && mfd->dcm_state != DCM_ENTER)
|| !mfd->bl_updated) && !IS_CALIB_MODE_BL(mfd)) {
@@ -896,6 +898,12 @@
pdata = dev_get_platdata(&mfd->pdev->dev);
if ((pdata) && (pdata->set_backlight)) {
+ if (mfd->mdp.ad_attenuate_bl) {
+ ret = (*mfd->mdp.ad_attenuate_bl)(bkl_lvl, &temp, mfd);
+ if (ret)
+ pr_err("Failed to attenuate BL\n");
+ }
+
mfd->bl_level_prev_scaled = mfd->bl_level_scaled;
if (!IS_CALIB_MODE_BL(mfd))
mdss_fb_scale_bl(mfd, &temp);
@@ -911,31 +919,42 @@
mfd->bl_level = bkl_lvl;
return;
}
+ pr_debug("backlight sent to panel :%d\n", temp);
pdata->set_backlight(pdata, temp);
mfd->bl_level = bkl_lvl;
mfd->bl_level_scaled = temp;
- if (mfd->mdp.update_ad_input) {
+ if (mfd->mdp.update_ad_input && is_bl_changed) {
update_ad_input = mfd->mdp.update_ad_input;
mutex_unlock(&mfd->bl_lock);
/* Will trigger ad_setup which will grab bl_lock */
update_ad_input(mfd);
- mdss_fb_bl_update_notify(mfd);
mutex_lock(&mfd->bl_lock);
}
+ mdss_fb_bl_update_notify(mfd);
}
}
void mdss_fb_update_backlight(struct msm_fb_data_type *mfd)
{
struct mdss_panel_data *pdata;
+ int ret = 0;
+ u32 temp;
mutex_lock(&mfd->bl_lock);
if (mfd->unset_bl_level && !mfd->bl_updated) {
pdata = dev_get_platdata(&mfd->pdev->dev);
if ((pdata) && (pdata->set_backlight)) {
mfd->bl_level = mfd->unset_bl_level;
- pdata->set_backlight(pdata, mfd->bl_level);
+ temp = mfd->bl_level;
+ if (mfd->mdp.ad_attenuate_bl) {
+ ret = (*mfd->mdp.ad_attenuate_bl)(temp,
+ &temp, mfd);
+ if (ret)
+ pr_err("Failed to attenuate BL\n");
+ }
+
+ pdata->set_backlight(pdata, temp);
mfd->bl_level_scaled = mfd->unset_bl_level;
mfd->bl_updated = 1;
}
diff --git a/drivers/video/msm/mdss/mdss_fb.h b/drivers/video/msm/mdss/mdss_fb.h
index fc53c55..1ab0fb7 100644
--- a/drivers/video/msm/mdss/mdss_fb.h
+++ b/drivers/video/msm/mdss/mdss_fb.h
@@ -123,6 +123,8 @@
int (*do_histogram)(struct msm_fb_data_type *mfd,
struct mdp_histogram *hist);
int (*update_ad_input)(struct msm_fb_data_type *mfd);
+ int (*ad_attenuate_bl)(u32 bl, u32 *bl_out,
+ struct msm_fb_data_type *mfd);
int (*panel_register_done)(struct mdss_panel_data *pdata);
u32 (*fb_stride)(u32 fb_index, u32 xres, int bpp);
int (*splash_init_fnc)(struct msm_fb_data_type *mfd);
diff --git a/drivers/video/msm/mdss/mdss_mdp_hwio.h b/drivers/video/msm/mdss/mdss_mdp_hwio.h
index d52a44a..0b67a6d 100644
--- a/drivers/video/msm/mdss/mdss_mdp_hwio.h
+++ b/drivers/video/msm/mdss/mdss_mdp_hwio.h
@@ -379,6 +379,7 @@
#define MDSS_MDP_MAX_AD_AL 65535
#define MDSS_MDP_MAX_AD_STR 255
+#define MDSS_MDP_AD_BL_SCALE 4095
#define MDSS_MDP_REG_AD_BYPASS 0x000
#define MDSS_MDP_REG_AD_CTRL_0 0x004
diff --git a/drivers/video/msm/mdss/mdss_mdp_overlay.c b/drivers/video/msm/mdss/mdss_mdp_overlay.c
index 437ebe4..f286de5 100644
--- a/drivers/video/msm/mdss/mdss_mdp_overlay.c
+++ b/drivers/video/msm/mdss/mdss_mdp_overlay.c
@@ -2271,6 +2271,11 @@
u32 copyback = 0;
u32 copy_from_kernel = 0;
+ if (mfd->panel_info->partial_update_enabled) {
+ pr_err("Partical update feature is enabled.");
+ return -EPERM;
+ }
+
ret = copy_from_user(&mdp_pp, argp, sizeof(mdp_pp));
if (ret)
return ret;
@@ -2384,6 +2389,11 @@
u32 pp_bus_handle;
static int req = -1;
+ if (mfd->panel_info->partial_update_enabled) {
+ pr_err("Partical update feature is enabled.");
+ return -EPERM;
+ }
+
switch (cmd) {
case MSMFB_HISTOGRAM_START:
if (!mfd->panel_power_on)
diff --git a/drivers/video/msm/mdss/mdss_mdp_pp.c b/drivers/video/msm/mdss/mdss_mdp_pp.c
index ad8e8a6..225862d 100644
--- a/drivers/video/msm/mdss/mdss_mdp_pp.c
+++ b/drivers/video/msm/mdss/mdss_mdp_pp.c
@@ -399,13 +399,27 @@
struct mdss_mdp_ctl *ctl, u32 num, u32 *opmode);
static int mdss_mdp_ad_setup(struct msm_fb_data_type *mfd);
static void pp_ad_cfg_lut(char __iomem *addr, u32 *data);
-static u32 pp_ad_attenuate_bl(u32 bl, struct mdss_ad_info *ad);
+static int pp_ad_attenuate_bl(u32 bl, u32 *bl_out,
+ struct msm_fb_data_type *mfd);
static int pp_num_to_side(struct mdss_mdp_ctl *ctl, u32 num);
static inline bool pp_sts_is_enabled(u32 sts, int side);
static inline void pp_sts_set_split_bits(u32 *sts, u32 bits);
static u32 last_sts, last_state;
+inline int linear_map(int in, int *out, int in_max, int out_max)
+{
+ if (in < 0 || !out || in_max <= 0 || out_max <= 0)
+ return -EINVAL;
+ *out = ((in * out_max) / in_max);
+ pr_debug("in = %d, out = %d, in_max = %d, out_max = %d\n",
+ in, *out, in_max, out_max);
+ if ((in > 0) && (*out == 0))
+ *out = 1;
+ return 0;
+
+}
+
int mdss_mdp_csc_setup_data(u32 block, u32 blk_idx, u32 tbl_idx,
struct mdp_csc_cfg *data)
{
@@ -814,19 +828,18 @@
* TODO: Allow pipe to be programmed whenever new CSC is
* applied (i.e. dirty bit)
*/
- if (pipe->play_cnt == 0)
- mdss_mdp_csc_setup_data(MDSS_MDP_BLOCK_SSPP,
- pipe->num, 1, &pipe->pp_cfg.csc_cfg);
+ mdss_mdp_csc_setup_data(MDSS_MDP_BLOCK_SSPP, pipe->num,
+ 1, &pipe->pp_cfg.csc_cfg);
} else {
- if (pipe->src_fmt->is_yuv)
+ if (pipe->src_fmt->is_yuv) {
opmode |= (0 << 19) | /* DST_DATA=RGB */
(1 << 18) | /* SRC_DATA=YCBCR */
(1 << 17); /* CSC_1_EN */
- /*
- * TODO: Needs to be part of dirty bit logic: if there is a
- * previously configured pipe need to re-configure CSC matrix
- */
- if (pipe->play_cnt == 0) {
+ /*
+ * TODO: Needs to be part of dirty bit logic: if there
+ * is a previously configured pipe need to re-configure
+ * CSC matrix
+ */
mdss_mdp_csc_setup(MDSS_MDP_BLOCK_SSPP, pipe->num, 1,
MDSS_MDP_CSC_YUV2RGB);
}
@@ -1749,9 +1762,13 @@
if (ad->state & PP_AD_STATE_BL_LIN) {
bl = ad->bl_lin[bl >> ad->bl_bright_shift];
bl = bl << ad->bl_bright_shift;
- bl = pp_ad_attenuate_bl(bl, ad);
+ ret = pp_ad_attenuate_bl(bl, &bl, ad->mfd);
+ if (ret)
+ pr_err("Failed to attenuate BL\n");
}
- ad->bl_data = bl;
+ linear_map(bl, &ad->bl_data,
+ ad->bl_mfd->panel_info->bl_max,
+ MDSS_MDP_AD_BL_SCALE);
pp_ad_input_write(&mdata->ad_off[dspp_num], ad);
}
if ((PP_AD_STATE_VSYNC & ad->state) && ad->calc_itr)
@@ -3905,6 +3922,11 @@
return -ENODEV;
}
+ if (ad_mfd->panel_info->type == DTV_PANEL) {
+ pr_debug("AD not supported on external display\n");
+ return ret;
+ }
+
mixer_num = mdss_mdp_get_ctl_mixers(ad_mfd->index, mixer_id);
if (!mixer_num) {
pr_debug("no mixers connected, %d", mixer_num);
@@ -4049,11 +4071,7 @@
} else if (init_cfg->ops & MDP_PP_AD_CFG) {
memcpy(&ad->cfg, &init_cfg->params.cfg,
sizeof(struct mdss_ad_cfg));
- /*
- * TODO: specify panel independent range of input from cfg,
- * scale input backlight_scale to panel bl_max's range
- */
- ad->cfg.backlight_scale = bl_mfd->panel_info->bl_max;
+ ad->cfg.backlight_scale = MDSS_MDP_AD_BL_SCALE;
ad->sts |= PP_AD_STS_DIRTY_CFG;
}
@@ -4176,7 +4194,7 @@
if (!ret) {
if (wait) {
mutex_lock(&ad->lock);
- init_completion(&ad->comp);
+ INIT_COMPLETION(ad->comp);
mutex_unlock(&ad->lock);
}
if (wait) {
@@ -4315,10 +4333,7 @@
frame_end = 0xFFFF;
procs_start = 0x0;
procs_end = 0xFFFF;
- if (split_mode)
- tile_ctrl = 0x0;
- else
- tile_ctrl = 0x1;
+ tile_ctrl = 0x0;
}
@@ -4471,9 +4486,13 @@
if (ad->state & PP_AD_STATE_BL_LIN) {
bl = ad->bl_lin[bl >> ad->bl_bright_shift];
bl = bl << ad->bl_bright_shift;
- bl = pp_ad_attenuate_bl(bl, ad);
+ ret = pp_ad_attenuate_bl(bl, &bl, ad->mfd);
+ if (ret)
+ pr_err("Failed to attenuate BL\n");
}
- ad->bl_data = bl;
+ linear_map(bl, &ad->bl_data,
+ ad->bl_mfd->panel_info->bl_max,
+ MDSS_MDP_AD_BL_SCALE);
}
mutex_unlock(&bl_mfd->bl_lock);
ad->reg_sts |= PP_AD_STS_DIRTY_DATA;
@@ -4523,6 +4542,7 @@
if (bl_mfd != mfd)
bl_mfd->ext_ad_ctrl = mfd->index;
bl_mfd->mdp.update_ad_input = pp_update_ad_input;
+ bl_mfd->mdp.ad_attenuate_bl = pp_ad_attenuate_bl;
bl_mfd->ext_bl_ctrl = ad->cfg.bl_ctrl_mode;
mutex_unlock(&bl_mfd->bl_lock);
@@ -4552,6 +4572,7 @@
memset(&ad->cfg, 0, sizeof(struct mdss_ad_cfg));
mutex_lock(&bl_mfd->bl_lock);
bl_mfd->mdp.update_ad_input = NULL;
+ bl_mfd->mdp.ad_attenuate_bl = NULL;
bl_mfd->ext_bl_ctrl = 0;
bl_mfd->ext_ad_ctrl = -1;
mutex_unlock(&bl_mfd->bl_lock);
@@ -4692,28 +4713,60 @@
addr + ((PP_AD_LUT_LEN - 1) * 2));
}
-static u32 pp_ad_attenuate_bl(u32 bl, struct mdss_ad_info *ad)
+static int pp_ad_attenuate_bl(u32 bl, u32 *bl_out,
+ struct msm_fb_data_type *mfd)
{
u32 shift = 0, ratio_temp = 0;
- u32 n, lut_interval, bl_att, out;
+ u32 n, lut_interval, bl_att;
+ int ret = -1;
+ struct mdss_ad_info *ad;
- ratio_temp = ad->cfg.backlight_max / (AD_BL_ATT_LUT_LEN - 1);
+ if (bl < 0) {
+ pr_err("Invalid backlight input\n");
+ return ret;
+ }
+
+ ret = mdss_mdp_get_ad(mfd, &ad);
+ if (ret || !ad || !ad->bl_mfd || !ad->bl_mfd->panel_info ||
+ !ad->bl_mfd->panel_info->bl_max || !ad->bl_att_lut) {
+ pr_err("Failed to get the ad.\n");
+ return ret;
+ }
+ pr_debug("bl_in = %d\n", bl);
+ /* map panel backlight range to AD backlight range */
+ linear_map(bl, &bl, ad->bl_mfd->panel_info->bl_max,
+ MDSS_MDP_AD_BL_SCALE);
+
+ pr_debug("Before attenuation = %d\n", bl);
+ ratio_temp = MDSS_MDP_AD_BL_SCALE / (AD_BL_ATT_LUT_LEN - 1);
while (ratio_temp > 0) {
ratio_temp = ratio_temp >> 1;
shift++;
}
n = bl >> shift;
- lut_interval = (ad->cfg.backlight_max + 1) / (AD_BL_ATT_LUT_LEN - 1);
+ if (n >= (AD_BL_ATT_LUT_LEN - 1)) {
+ pr_err("Invalid index for BL attenuation: %d.\n", n);
+ return ret;
+ }
+ lut_interval = (MDSS_MDP_AD_BL_SCALE + 1) / (AD_BL_ATT_LUT_LEN - 1);
bl_att = ad->bl_att_lut[n] + (bl - lut_interval * n) *
(ad->bl_att_lut[n + 1] - ad->bl_att_lut[n]) /
lut_interval;
+ pr_debug("n = %d, bl_att = %d\n", n, bl_att);
if (ad->init.alpha_base)
- out = (ad->init.alpha * bl_att +
+ *bl_out = (ad->init.alpha * bl_att +
(ad->init.alpha_base - ad->init.alpha) * bl) /
ad->init.alpha_base;
else
- out = bl;
- return out;
+ *bl_out = bl;
+
+ pr_debug("After attenuation = %d\n", *bl_out);
+ /* map AD backlight range back to panel backlight range */
+ linear_map(*bl_out, bl_out, MDSS_MDP_AD_BL_SCALE,
+ ad->bl_mfd->panel_info->bl_max);
+
+ pr_debug("bl_out = %d\n", *bl_out);
+ return 0;
}
int mdss_mdp_ad_addr_setup(struct mdss_data_type *mdata, u32 *ad_offsets)
@@ -4751,6 +4804,7 @@
mdata->ad_cfgs[i].last_str = 0xFFFFFFFF;
mdata->ad_cfgs[i].last_bl = 0;
mutex_init(&mdata->ad_cfgs[i].lock);
+ init_completion(&mdata->ad_cfgs[i].comp);
mdata->ad_cfgs[i].handle.vsync_handler = pp_ad_vsync_handler;
mdata->ad_cfgs[i].handle.cmd_post_flush = true;
INIT_WORK(&mdata->ad_cfgs[i].calc_work, pp_ad_calc_worker);