static ssize_t mipi_samsung_fps_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct msm_fb_data_type *mfd = NULL;
int goal_fps;
int level = atoi(buf);
mfd = platform_get_drvdata(msd.msm_pdev);
if (unlikely(!mfd))
return -ENODEV;
if (unlikely(mfd->key != MFD_KEY))
return -EINVAL;
if (mdp_fb_is_power_off(mfd)) {
pr_err("%s fps set error, panel power off 1", __func__);
return size;
}
if (level == 0)
goal_fps = 60;
else if (level == 1)
goal_fps = 42;
else if (level == 2)
goal_fps = 51;
else {
pr_info("%s fps set error : invalid level %d", __func__, level);
return size;
}
if (current_fps != goal_fps)
current_fps = goal_fps;
else
return size;
mutex_lock(&dsi_tx_mutex);
if (mdp_fb_is_power_off(mfd)) {
mutex_unlock(&dsi_tx_mutex);
pr_info("%s fps set error, panel power off 2", __func__);
return size;
} else {
mipi_runtime_clk_change(current_fps);
mutex_unlock(&dsi_tx_mutex);
}
pr_info("%s goal_fps : %d", __func__, goal_fps);
return size;
}
int prepare_for_reg_access(struct msm_fb_data_type *mfd)
{
struct device *dev = &mfd->panel_pdev->dev;
struct mipi_dsi_data *dsi_data;
int ret = 0;
dsi_data = platform_get_drvdata(mfd->panel_pdev);
#ifdef CONFIG_FB_MSM_RECOVER_PANEL
mutex_lock(&mfd->nvrw_prohibit_draw);
#endif
/* Needed to make sure the display stack isn't powered on/off while */
/* we are executing. Also locks in msm_fb.c */
mutex_lock(&mfd->power_lock);
if (mdp_fb_is_power_off(mfd)) {
dev_err(dev, "%s: panel is OFF, not supported\n", __func__);
mutex_unlock(&mfd->power_lock);
#ifdef CONFIG_FB_MSM_RECOVER_PANEL
mutex_unlock(&mfd->nvrw_prohibit_draw);
#endif
ret = -EINVAL;
goto exit;
}
mutex_lock(&mfd->dma->ov_mutex);
if (mfd->panel_info.mipi.mode == DSI_VIDEO_MODE) {
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0);
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
msleep(ONE_FRAME_TRANSMIT_WAIT_MS);
mipi_dsi_controller_cfg_toggle(0);
mipi_dsi_op_mode_config(DSI_CMD_MODE);
}
exit:
return ret;
}
static ssize_t mipi_samsung_disp_set_power(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct msm_fb_data_type *mfd = NULL;
unsigned int power;
mfd = platform_get_drvdata(msd.msm_pdev);
if (unlikely(!mfd))
return -ENODEV;
if (unlikely(mfd->key != MFD_KEY))
return -EINVAL;
if (sscanf(buf, "%u", &power) != 1)
return -EINVAL;
if (power == !mdp_fb_is_power_off(mfd))
return 0;
if (power) {
mfd->fbi->fbops->fb_blank(FB_BLANK_UNBLANK, mfd->fbi);
mfd->fbi->fbops->fb_pan_display(&mfd->fbi->var, mfd->fbi);
mipi_samsung_disp_send_cmd(mfd, PANEL_LATE_ON, true);
mipi_samsung_disp_backlight(mfd);
} else {
mfd->fbi->fbops->fb_blank(FB_BLANK_POWERDOWN, mfd->fbi);
}
pr_info("mipi_samsung_disp_set_power\n");
return size;
}
void lcd_hsync_onoff(bool onoff)
{
struct msm_fb_data_type *mfd;
mfd = platform_get_drvdata(msd.msm_pdev);
if (unlikely(!mfd)) { pr_err("%s : panel no mfd",__func__); return;}
// return -ENODEV;
if (unlikely(mfd->key != MFD_KEY)) { pr_err("%s : panel mfd invlaid",__func__); return;}
// return -EINVAL;
#if defined(CONFIG_MACH_JACTIVE_EUR) /* HW DEFECT under REV 0.5 */
if( system_rev > 16 )
return;
#endif
if (!mdp_fb_is_power_off(mfd))
{
if( onoff )
{
msleep(30);
mipi_samsung_disp_send_cmd(mfd, PANEL_HSYNC_ON, true);
pr_info("%s : HSYNC On\n",__func__);
}
else
{
mipi_samsung_disp_send_cmd(mfd, PANEL_HSYNC_OFF, true);
msleep(10); /* Need time to discharging by capacitance*/
pr_info("%s : HSYNC Off\n",__func__);
}
}
else
pr_err("%s : panel power off\n",__func__);
return;
}
static ssize_t mipi_samsung_disp_get_power(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct msm_fb_data_type *mfd = NULL;
int rc;
mfd = platform_get_drvdata(msd.msm_pdev);
if (unlikely(!mfd))
return -ENODEV;
if (unlikely(mfd->key != MFD_KEY))
return -EINVAL;
rc = snprintf((char *)buf, sizeof(*buf), "%d\n", !mdp_fb_is_power_off(mfd));
pr_info("mipi_samsung_disp_get_power(%d)\n", !mdp_fb_is_power_off(mfd));
return rc;
}
void mdp4_atv_overlay(struct msm_fb_data_type *mfd)
{
struct fb_info *fbi = mfd->fbi;
uint8 *buf;
unsigned int buf_offset;
int bpp;
unsigned long flag;
struct mdp4_overlay_pipe *pipe;
if (mdp_fb_is_power_off(mfd))
return;
/* no need to power on cmd block since it's lcdc mode */
bpp = fbi->var.bits_per_pixel / 8;
buf = (uint8 *) fbi->fix.smem_start;
buf_offset = calc_fb_offset(mfd, fbi, bpp);
mutex_lock(&mfd->dma->ov_mutex);
pipe = atv_pipe;
if (mfd->map_buffer) {
pipe->srcp0_addr = (unsigned int)mfd->map_buffer->iova[0] + \
buf_offset;
pr_debug("start 0x%lx srcp0_addr 0x%x\n", mfd->
map_buffer->iova[0], pipe->srcp0_addr);
} else {
pipe->srcp0_addr = (uint32)(buf + buf_offset);
}
mdp_update_pm(mfd, vsync_ctrl_db[0].vsync_time);
mdp4_overlay_mdp_perf_req(pipe, mfd);
mdp4_overlay_mdp_perf_upd(mfd, 1);
mdp4_overlay_rgb_setup(pipe);
mdp4_overlay_reg_flush(pipe, 0);
mdp4_mixer_stage_up(pipe, 0);
mdp4_mixer_stage_commit(pipe->mixer_num);
printk(KERN_INFO "mdp4_atv_overlay: pipe=%x ndx=%d\n",
(int)pipe, pipe->pipe_ndx);
/* enable irq */
spin_lock_irqsave(&mdp_spin_lock, flag);
mdp_enable_irq(MDP_OVERLAY1_TERM);
INIT_COMPLETION(atv_pipe->comp);
mfd->dma->waiting = TRUE;
outp32(MDP_INTR_CLEAR, INTR_OVERLAY1_DONE);
mdp_intr_mask |= INTR_OVERLAY1_DONE;
outp32(MDP_INTR_ENABLE, mdp_intr_mask);
spin_unlock_irqrestore(&mdp_spin_lock, flag);
wait_for_completion_killable(&atv_pipe->comp);
mdp_disable_irq(MDP_OVERLAY1_TERM);
mdp4_overlay_mdp_perf_upd(mfd, 0);
mdp4_stat.kickoff_atv++;
mutex_unlock(&mfd->dma->ov_mutex);
}
void mdp4_dsi_video_overlay(struct msm_fb_data_type *mfd)
{
struct fb_info *fbi = mfd->fbi;
uint8 *buf;
unsigned int buf_offset;
int bpp;
int cnt, cndx = 0;
struct vsycn_ctrl *vctrl;
struct mdp4_overlay_pipe *pipe;
mutex_lock(&mfd->dma->ov_mutex);
vctrl = &vsync_ctrl_db[cndx];
pipe = vctrl->base_pipe;
if (!pipe || mdp_fb_is_power_off(mfd)) {
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
pr_debug("%s: cpu=%d pid=%d\n", __func__,
smp_processor_id(), current->pid);
if (pipe->pipe_type == OVERLAY_TYPE_RGB) {
bpp = fbi->var.bits_per_pixel / 8;
buf = (uint8 *) fbi->fix.smem_start;
buf_offset = calc_fb_offset(mfd, fbi, bpp);
if (mfd->display_iova)
pipe->srcp0_addr = mfd->display_iova + buf_offset;
else
pipe->srcp0_addr = (uint32)(buf + buf_offset);
mdp4_dsi_video_pipe_queue(0, pipe);
}
mdp4_overlay_mdp_perf_upd(mfd, 1);
cnt = mdp4_dsi_video_pipe_commit(cndx, 0);
if (cnt >= 0) {
if (pipe->ov_blt_addr)
mdp4_dsi_video_wait4ov(cndx);
else
mdp4_dsi_video_wait4dmap(cndx);
}
mdp4_dsi_panel_on(mfd);
mdp4_overlay_mdp_perf_upd(mfd, 0);
mutex_unlock(&mfd->dma->ov_mutex);
}
void mdp4_dtv_overlay(struct msm_fb_data_type *mfd)
{
int cndx = 0;
struct vsycn_ctrl *vctrl;
struct mdp4_overlay_pipe *pipe;
mutex_lock(&mfd->dma->ov_mutex);
if (mdp_fb_is_power_off(mfd)) {
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
vctrl = &vsync_ctrl_db[cndx];
if (vctrl->base_pipe == NULL)
mdp4_overlay_dtv_set(mfd, NULL);
pipe = vctrl->base_pipe;
if (pipe == NULL) {
pr_warn("%s: dtv_pipe == NULL\n", __func__);
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
if (hdmi_prim_display && (pipe->pipe_used == 0 ||
pipe->mixer_stage != MDP4_MIXER_STAGE_BASE)) {
pr_err("%s: NOT baselayer\n", __func__);
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
if (pipe->pipe_type == OVERLAY_TYPE_RGB) {
pipe->srcp0_addr = (uint32)mfd->ibuf.buf;
mdp4_dtv_pipe_queue(0, pipe);
}
mdp4_overlay_mdp_perf_upd(mfd, 1);
mdp4_dtv_pipe_commit(0, 1);
mdp4_overlay_mdp_perf_upd(mfd, 0);
mutex_unlock(&mfd->dma->ov_mutex);
}
void mdp4_dsi_cmd_overlay(struct msm_fb_data_type *mfd)
{
int cndx = 0;
struct vsycn_ctrl *vctrl;
struct mdp4_overlay_pipe *pipe;
mutex_lock(&mfd->dma->ov_mutex);
vctrl = &vsync_ctrl_db[cndx];
if (mdp_fb_is_power_off(mfd)) {
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
pipe = vctrl->base_pipe;
if (pipe == NULL) {
pr_err("%s: NO base pipe\n", __func__);
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
if (mdp4_dsi_cmd_clk_check(vctrl) < 0) {
mutex_unlock(&mfd->dma->ov_mutex);
return;
}
if (pipe->mixer_stage == MDP4_MIXER_STAGE_BASE) {
mdp4_mipi_vsync_enable(mfd, pipe, 0);
mdp4_overlay_setup_pipe_addr(mfd, pipe);
mdp4_dsi_cmd_pipe_queue(0, pipe);
}
mdp4_overlay_mdp_perf_upd(mfd, 1);
mdp4_dsi_cmd_pipe_commit(cndx, 0);
mdp4_overlay_mdp_perf_upd(mfd, 0);
mutex_unlock(&mfd->dma->ov_mutex);
}
static ssize_t store_eco_mode(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
ssize_t ret;
struct platform_device *pdev;
struct mipi_dsi_data *dsi_data;
struct msm_fb_data_type *mfd;
struct msm_fb_panel_data *pdata = NULL;
pdev = container_of(dev, struct platform_device, dev);
mfd = platform_get_drvdata(pdev);
dsi_data = platform_get_drvdata(mfd->panel_pdev);
pdata = (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data;
if (sscanf(buf, "%i", &ret) != 1) {
printk(KERN_ERR"Invalid flag for eco_mode\n");
goto exit;
}
if (ret)
dsi_data->eco_mode_on = true;
else
dsi_data->eco_mode_on = false;
if (!mdp_fb_is_power_off(mfd))
dsi_data->eco_mode_switch(mfd);
exit:
ret = strnlen(buf, count);
return ret;
}
