![Stepan Moskovchenko](/assets/img/avatar_default.png)
Qualcomm development of the MSM SOC framebuffer driver has diverged significantly from the driver used by Android. This is a snapshot of our current driver, in all it's agony. We are putting this in staging to help with the process of converging the two drivers. At this point, the driver has been tested only in dumb framebuffer mode. Signed-off-by: Stepan Moskovchenko <stepanm@codeaurora.org> Signed-off-by: David Brown <davidb@codeaurora.org> Signed-off-by: Abhijeet Dharmapurikar <adharmap@codeaurora.org> [dwalker@codeaurora.org: added a small compile fix and TODO.] Signed-off-by: Daniel Walker <dwalker@codeaurora.org> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
1114 lines
26 KiB
C
1114 lines
26 KiB
C
/* Copyright (c) 2008-2010, Code Aurora Forum. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 and
|
|
* only version 2 as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301, USA.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/time.h>
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/hrtimer.h>
|
|
#include <linux/clk.h>
|
|
#include <mach/hardware.h>
|
|
#include <linux/io.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/mutex.h>
|
|
|
|
#include <asm/system.h>
|
|
#include <asm/mach-types.h>
|
|
#include <linux/semaphore.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
#include "mdp.h"
|
|
#include "msm_fb.h"
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
#include "mdp4.h"
|
|
#endif
|
|
|
|
static struct clk *mdp_clk;
|
|
static struct clk *mdp_pclk;
|
|
|
|
struct completion mdp_ppp_comp;
|
|
struct semaphore mdp_ppp_mutex;
|
|
struct semaphore mdp_pipe_ctrl_mutex;
|
|
|
|
unsigned long mdp_timer_duration = (HZ); /* 1 sec */
|
|
/* unsigned long mdp_mdp_timer_duration=0; */
|
|
|
|
boolean mdp_ppp_waiting = FALSE;
|
|
uint32 mdp_tv_underflow_cnt;
|
|
uint32 mdp_lcdc_underflow_cnt;
|
|
|
|
boolean mdp_current_clk_on = FALSE;
|
|
boolean mdp_is_in_isr = FALSE;
|
|
|
|
/*
|
|
* legacy mdp_in_processing is only for DMA2-MDDI
|
|
* this applies to DMA2 block only
|
|
*/
|
|
uint32 mdp_in_processing = FALSE;
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
uint32 mdp_intr_mask = MDP4_ANY_INTR_MASK;
|
|
#else
|
|
uint32 mdp_intr_mask = MDP_ANY_INTR_MASK;
|
|
#endif
|
|
|
|
MDP_BLOCK_TYPE mdp_debug[MDP_MAX_BLOCK];
|
|
|
|
int32 mdp_block_power_cnt[MDP_MAX_BLOCK];
|
|
|
|
spinlock_t mdp_spin_lock;
|
|
struct workqueue_struct *mdp_dma_wq; /*mdp dma wq */
|
|
struct workqueue_struct *mdp_vsync_wq; /*mdp vsync wq */
|
|
|
|
static struct workqueue_struct *mdp_pipe_ctrl_wq; /* mdp mdp pipe ctrl wq */
|
|
static struct delayed_work mdp_pipe_ctrl_worker;
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
struct mdp_dma_data dma2_data;
|
|
struct mdp_dma_data dma_s_data;
|
|
struct mdp_dma_data dma_e_data;
|
|
#else
|
|
static struct mdp_dma_data dma2_data;
|
|
static struct mdp_dma_data dma_s_data;
|
|
static struct mdp_dma_data dma_e_data;
|
|
#endif
|
|
static struct mdp_dma_data dma3_data;
|
|
|
|
extern ktime_t mdp_dma2_last_update_time;
|
|
|
|
extern uint32 mdp_dma2_update_time_in_usec;
|
|
extern int mdp_lcd_rd_cnt_offset_slow;
|
|
extern int mdp_lcd_rd_cnt_offset_fast;
|
|
extern int mdp_usec_diff_threshold;
|
|
|
|
#ifdef CONFIG_FB_MSM_LCDC
|
|
extern int mdp_lcdc_pclk_clk_rate;
|
|
extern int mdp_lcdc_pad_pclk_clk_rate;
|
|
extern int first_pixel_start_x;
|
|
extern int first_pixel_start_y;
|
|
#endif
|
|
|
|
#ifdef MSM_FB_ENABLE_DBGFS
|
|
struct dentry *mdp_dir;
|
|
#endif
|
|
|
|
#if defined(CONFIG_PM) && !defined(CONFIG_HAS_EARLYSUSPEND)
|
|
static int mdp_suspend(struct platform_device *pdev, pm_message_t state);
|
|
#else
|
|
#define mdp_suspend NULL
|
|
#endif
|
|
|
|
struct timeval mdp_dma2_timeval;
|
|
struct timeval mdp_ppp_timeval;
|
|
|
|
#ifdef CONFIG_HAS_EARLYSUSPEND
|
|
static struct early_suspend early_suspend;
|
|
#endif
|
|
|
|
#ifndef CONFIG_FB_MSM_MDP22
|
|
DEFINE_MUTEX(mdp_lut_push_sem);
|
|
static int mdp_lut_i;
|
|
static int mdp_lut_hw_update(struct fb_cmap *cmap)
|
|
{
|
|
int i;
|
|
u16 *c[3];
|
|
u16 r, g, b;
|
|
|
|
c[0] = cmap->green;
|
|
c[1] = cmap->blue;
|
|
c[2] = cmap->red;
|
|
|
|
for (i = 0; i < cmap->len; i++) {
|
|
if (copy_from_user(&r, cmap->red++, sizeof(r)) ||
|
|
copy_from_user(&g, cmap->green++, sizeof(g)) ||
|
|
copy_from_user(&b, cmap->blue++, sizeof(b)))
|
|
return -EFAULT;
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
MDP_OUTP(MDP_BASE + 0x94800 +
|
|
#else
|
|
MDP_OUTP(MDP_BASE + 0x93800 +
|
|
#endif
|
|
(0x400*mdp_lut_i) + cmap->start*4 + i*4,
|
|
((g & 0xff) |
|
|
((b & 0xff) << 8) |
|
|
((r & 0xff) << 16)));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mdp_lut_push;
|
|
static int mdp_lut_push_i;
|
|
static int mdp_lut_update_nonlcdc(struct fb_info *info, struct fb_cmap *cmap)
|
|
{
|
|
int ret;
|
|
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
ret = mdp_lut_hw_update(cmap);
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
|
|
|
|
if (ret)
|
|
return ret;
|
|
|
|
mutex_lock(&mdp_lut_push_sem);
|
|
mdp_lut_push = 1;
|
|
mdp_lut_push_i = mdp_lut_i;
|
|
mutex_unlock(&mdp_lut_push_sem);
|
|
|
|
mdp_lut_i = (mdp_lut_i + 1)%2;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mdp_lut_update_lcdc(struct fb_info *info, struct fb_cmap *cmap)
|
|
{
|
|
int ret;
|
|
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
ret = mdp_lut_hw_update(cmap);
|
|
|
|
if (ret) {
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
|
|
return ret;
|
|
}
|
|
|
|
MDP_OUTP(MDP_BASE + 0x90070, (mdp_lut_i << 10) | 0x17);
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
|
|
mdp_lut_i = (mdp_lut_i + 1)%2;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define MDP_HIST_MAX_BIN 32
|
|
static __u32 mdp_hist_r[MDP_HIST_MAX_BIN];
|
|
static __u32 mdp_hist_g[MDP_HIST_MAX_BIN];
|
|
static __u32 mdp_hist_b[MDP_HIST_MAX_BIN];
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
struct mdp_histogram mdp_hist;
|
|
struct completion mdp_hist_comp;
|
|
#else
|
|
static struct mdp_histogram mdp_hist;
|
|
static struct completion mdp_hist_comp;
|
|
#endif
|
|
|
|
static int mdp_do_histogram(struct fb_info *info, struct mdp_histogram *hist)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!hist->frame_cnt || (hist->bin_cnt == 0) ||
|
|
(hist->bin_cnt > MDP_HIST_MAX_BIN))
|
|
return -EINVAL;
|
|
|
|
INIT_COMPLETION(mdp_hist_comp);
|
|
|
|
mdp_hist.bin_cnt = hist->bin_cnt;
|
|
mdp_hist.r = (hist->r) ? mdp_hist_r : 0;
|
|
mdp_hist.g = (hist->g) ? mdp_hist_g : 0;
|
|
mdp_hist.b = (hist->b) ? mdp_hist_b : 0;
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
MDP_OUTP(MDP_BASE + 0x95004, hist->frame_cnt);
|
|
MDP_OUTP(MDP_BASE + 0x95000, 1);
|
|
#else
|
|
MDP_OUTP(MDP_BASE + 0x94004, hist->frame_cnt);
|
|
MDP_OUTP(MDP_BASE + 0x94000, 1);
|
|
#endif
|
|
wait_for_completion_killable(&mdp_hist_comp);
|
|
|
|
if (hist->r) {
|
|
ret = copy_to_user(hist->r, mdp_hist.r, hist->bin_cnt*4);
|
|
if (ret)
|
|
goto hist_err;
|
|
}
|
|
if (hist->g) {
|
|
ret = copy_to_user(hist->g, mdp_hist.g, hist->bin_cnt*4);
|
|
if (ret)
|
|
goto hist_err;
|
|
}
|
|
if (hist->b) {
|
|
ret = copy_to_user(hist->b, mdp_hist.b, hist->bin_cnt*4);
|
|
if (ret)
|
|
goto hist_err;
|
|
}
|
|
return 0;
|
|
|
|
hist_err:
|
|
printk(KERN_ERR "%s: invalid hist buffer\n", __func__);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/* Returns < 0 on error, 0 on timeout, or > 0 on successful wait */
|
|
|
|
int mdp_ppp_pipe_wait(void)
|
|
{
|
|
int ret = 1;
|
|
|
|
/* wait 5 seconds for the operation to complete before declaring
|
|
the MDP hung */
|
|
|
|
if (mdp_ppp_waiting == TRUE) {
|
|
ret = wait_for_completion_interruptible_timeout(&mdp_ppp_comp,
|
|
5 * HZ);
|
|
|
|
if (!ret)
|
|
printk(KERN_ERR "%s: Timed out waiting for the MDP.\n",
|
|
__func__);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static DEFINE_SPINLOCK(mdp_lock);
|
|
static int mdp_irq_mask;
|
|
static int mdp_irq_enabled;
|
|
|
|
void mdp_enable_irq(uint32 term)
|
|
{
|
|
unsigned long irq_flags;
|
|
|
|
spin_lock_irqsave(&mdp_lock, irq_flags);
|
|
if (mdp_irq_mask & term) {
|
|
printk(KERN_ERR "MDP IRQ term-0x%x is already set\n", term);
|
|
} else {
|
|
mdp_irq_mask |= term;
|
|
if (mdp_irq_mask && !mdp_irq_enabled) {
|
|
mdp_irq_enabled = 1;
|
|
enable_irq(INT_MDP);
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&mdp_lock, irq_flags);
|
|
}
|
|
|
|
void mdp_disable_irq(uint32 term)
|
|
{
|
|
unsigned long irq_flags;
|
|
|
|
spin_lock_irqsave(&mdp_lock, irq_flags);
|
|
if (!(mdp_irq_mask & term)) {
|
|
printk(KERN_ERR "MDP IRQ term-0x%x is not set\n", term);
|
|
} else {
|
|
mdp_irq_mask &= ~term;
|
|
if (!mdp_irq_mask && mdp_irq_enabled) {
|
|
mdp_irq_enabled = 0;
|
|
disable_irq(INT_MDP);
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&mdp_lock, irq_flags);
|
|
}
|
|
|
|
void mdp_disable_irq_nolock(uint32 term)
|
|
{
|
|
|
|
if (!(mdp_irq_mask & term)) {
|
|
printk(KERN_ERR "MDP IRQ term-0x%x is not set\n", term);
|
|
} else {
|
|
mdp_irq_mask &= ~term;
|
|
if (!mdp_irq_mask && mdp_irq_enabled) {
|
|
mdp_irq_enabled = 0;
|
|
disable_irq(INT_MDP);
|
|
}
|
|
}
|
|
}
|
|
|
|
void mdp_pipe_kickoff(uint32 term, struct msm_fb_data_type *mfd)
|
|
{
|
|
|
|
dmb(); /* memory barrier */
|
|
|
|
/* kick off PPP engine */
|
|
if (term == MDP_PPP_TERM) {
|
|
if (mdp_debug[MDP_PPP_BLOCK])
|
|
jiffies_to_timeval(jiffies, &mdp_ppp_timeval);
|
|
|
|
/* let's turn on PPP block */
|
|
mdp_pipe_ctrl(MDP_PPP_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
|
|
mdp_enable_irq(term);
|
|
INIT_COMPLETION(mdp_ppp_comp);
|
|
mdp_ppp_waiting = TRUE;
|
|
outpdw(MDP_BASE + 0x30, 0x1000);
|
|
wait_for_completion_killable(&mdp_ppp_comp);
|
|
mdp_disable_irq(term);
|
|
|
|
if (mdp_debug[MDP_PPP_BLOCK]) {
|
|
struct timeval now;
|
|
|
|
jiffies_to_timeval(jiffies, &now);
|
|
mdp_ppp_timeval.tv_usec =
|
|
now.tv_usec - mdp_ppp_timeval.tv_usec;
|
|
MSM_FB_INFO("MDP-PPP: %d\n",
|
|
(int)mdp_ppp_timeval.tv_usec);
|
|
}
|
|
} else if (term == MDP_DMA2_TERM) {
|
|
if (mdp_debug[MDP_DMA2_BLOCK]) {
|
|
MSM_FB_INFO("MDP-DMA2: %d\n",
|
|
(int)mdp_dma2_timeval.tv_usec);
|
|
jiffies_to_timeval(jiffies, &mdp_dma2_timeval);
|
|
}
|
|
/* DMA update timestamp */
|
|
mdp_dma2_last_update_time = ktime_get_real();
|
|
/* let's turn on DMA2 block */
|
|
#if 0
|
|
mdp_pipe_ctrl(MDP_DMA2_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
#endif
|
|
#ifdef CONFIG_FB_MSM_MDP22
|
|
outpdw(MDP_CMD_DEBUG_ACCESS_BASE + 0x0044, 0x0);/* start DMA */
|
|
#else
|
|
if (mdp_lut_push) {
|
|
mutex_lock(&mdp_lut_push_sem);
|
|
mdp_lut_push = 0;
|
|
MDP_OUTP(MDP_BASE + 0x90070,
|
|
(mdp_lut_push_i << 10) | 0x17);
|
|
mutex_unlock(&mdp_lut_push_sem);
|
|
}
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
outpdw(MDP_BASE + 0x000c, 0x0); /* start DMA */
|
|
#else
|
|
outpdw(MDP_BASE + 0x0044, 0x0); /* start DMA */
|
|
#endif
|
|
#endif
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
} else if (term == MDP_DMA_S_TERM) {
|
|
mdp_pipe_ctrl(MDP_DMA_S_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
outpdw(MDP_BASE + 0x0010, 0x0); /* start DMA */
|
|
} else if (term == MDP_DMA_E_TERM) {
|
|
mdp_pipe_ctrl(MDP_DMA_E_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
outpdw(MDP_BASE + 0x0014, 0x0); /* start DMA */
|
|
} else if (term == MDP_OVERLAY0_TERM) {
|
|
mdp_pipe_ctrl(MDP_OVERLAY0_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
outpdw(MDP_BASE + 0x0004, 0);
|
|
} else if (term == MDP_OVERLAY1_TERM) {
|
|
mdp_pipe_ctrl(MDP_OVERLAY1_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
outpdw(MDP_BASE + 0x0008, 0);
|
|
}
|
|
#else
|
|
} else if (term == MDP_DMA_S_TERM) {
|
|
mdp_pipe_ctrl(MDP_DMA_S_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
|
|
outpdw(MDP_BASE + 0x0048, 0x0); /* start DMA */
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void mdp_pipe_ctrl_workqueue_handler(struct work_struct *work)
|
|
{
|
|
mdp_pipe_ctrl(MDP_MASTER_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
|
|
}
|
|
|
|
void mdp_pipe_ctrl(MDP_BLOCK_TYPE block, MDP_BLOCK_POWER_STATE state,
|
|
boolean isr)
|
|
{
|
|
boolean mdp_all_blocks_off = TRUE;
|
|
int i;
|
|
unsigned long flag;
|
|
|
|
spin_lock_irqsave(&mdp_spin_lock, flag);
|
|
if (MDP_BLOCK_POWER_ON == state) {
|
|
mdp_block_power_cnt[block]++;
|
|
|
|
if (MDP_DMA2_BLOCK == block)
|
|
mdp_in_processing = TRUE;
|
|
} else {
|
|
mdp_block_power_cnt[block]--;
|
|
|
|
if (mdp_block_power_cnt[block] < 0) {
|
|
/*
|
|
* Master has to serve a request to power off MDP always
|
|
* It also has a timer to power off. So, in case of
|
|
* timer expires first and DMA2 finishes later,
|
|
* master has to power off two times
|
|
* There shouldn't be multiple power-off request for
|
|
* other blocks
|
|
*/
|
|
if (block != MDP_MASTER_BLOCK) {
|
|
MSM_FB_INFO("mdp_block_power_cnt[block=%d] \
|
|
multiple power-off request\n", block);
|
|
}
|
|
mdp_block_power_cnt[block] = 0;
|
|
}
|
|
|
|
if (MDP_DMA2_BLOCK == block)
|
|
mdp_in_processing = FALSE;
|
|
}
|
|
spin_unlock_irqrestore(&mdp_spin_lock, flag);
|
|
|
|
/*
|
|
* If it's in isr, we send our request to workqueue.
|
|
* Otherwise, processing happens in the current context
|
|
*/
|
|
if (isr) {
|
|
/* checking all blocks power state */
|
|
for (i = 0; i < MDP_MAX_BLOCK; i++) {
|
|
if (mdp_block_power_cnt[i] > 0)
|
|
mdp_all_blocks_off = FALSE;
|
|
}
|
|
|
|
if ((mdp_all_blocks_off) && (mdp_current_clk_on)) {
|
|
/* send workqueue to turn off mdp power */
|
|
queue_delayed_work(mdp_pipe_ctrl_wq,
|
|
&mdp_pipe_ctrl_worker,
|
|
mdp_timer_duration);
|
|
}
|
|
} else {
|
|
down(&mdp_pipe_ctrl_mutex);
|
|
/* checking all blocks power state */
|
|
for (i = 0; i < MDP_MAX_BLOCK; i++) {
|
|
if (mdp_block_power_cnt[i] > 0)
|
|
mdp_all_blocks_off = FALSE;
|
|
}
|
|
|
|
/*
|
|
* find out whether a delayable work item is currently
|
|
* pending
|
|
*/
|
|
|
|
if (delayed_work_pending(&mdp_pipe_ctrl_worker)) {
|
|
/*
|
|
* try to cancel the current work if it fails to
|
|
* stop (which means del_timer can't delete it
|
|
* from the list, it's about to expire and run),
|
|
* we have to let it run. queue_delayed_work won't
|
|
* accept the next job which is same as
|
|
* queue_delayed_work(mdp_timer_duration = 0)
|
|
*/
|
|
cancel_delayed_work(&mdp_pipe_ctrl_worker);
|
|
}
|
|
|
|
if ((mdp_all_blocks_off) && (mdp_current_clk_on)) {
|
|
if (block == MDP_MASTER_BLOCK) {
|
|
mdp_current_clk_on = FALSE;
|
|
/* turn off MDP clks */
|
|
if (mdp_clk != NULL) {
|
|
clk_disable(mdp_clk);
|
|
MSM_FB_DEBUG("MDP CLK OFF\n");
|
|
}
|
|
if (mdp_pclk != NULL) {
|
|
clk_disable(mdp_pclk);
|
|
MSM_FB_DEBUG("MDP PCLK OFF\n");
|
|
}
|
|
} else {
|
|
/* send workqueue to turn off mdp power */
|
|
queue_delayed_work(mdp_pipe_ctrl_wq,
|
|
&mdp_pipe_ctrl_worker,
|
|
mdp_timer_duration);
|
|
}
|
|
} else if ((!mdp_all_blocks_off) && (!mdp_current_clk_on)) {
|
|
mdp_current_clk_on = TRUE;
|
|
/* turn on MDP clks */
|
|
if (mdp_clk != NULL) {
|
|
clk_enable(mdp_clk);
|
|
MSM_FB_DEBUG("MDP CLK ON\n");
|
|
}
|
|
if (mdp_pclk != NULL) {
|
|
clk_enable(mdp_pclk);
|
|
MSM_FB_DEBUG("MDP PCLK ON\n");
|
|
}
|
|
}
|
|
up(&mdp_pipe_ctrl_mutex);
|
|
}
|
|
}
|
|
|
|
#ifndef CONFIG_FB_MSM_MDP40
|
|
irqreturn_t mdp_isr(int irq, void *ptr)
|
|
{
|
|
uint32 mdp_interrupt = 0;
|
|
struct mdp_dma_data *dma;
|
|
|
|
mdp_is_in_isr = TRUE;
|
|
do {
|
|
mdp_interrupt = inp32(MDP_INTR_STATUS);
|
|
outp32(MDP_INTR_CLEAR, mdp_interrupt);
|
|
|
|
mdp_interrupt &= mdp_intr_mask;
|
|
|
|
if (mdp_interrupt & TV_ENC_UNDERRUN) {
|
|
mdp_interrupt &= ~(TV_ENC_UNDERRUN);
|
|
mdp_tv_underflow_cnt++;
|
|
}
|
|
|
|
if (!mdp_interrupt)
|
|
break;
|
|
|
|
/* DMA3 TV-Out Start */
|
|
if (mdp_interrupt & TV_OUT_DMA3_START) {
|
|
/* let's disable TV out interrupt */
|
|
mdp_intr_mask &= ~TV_OUT_DMA3_START;
|
|
outp32(MDP_INTR_ENABLE, mdp_intr_mask);
|
|
|
|
dma = &dma3_data;
|
|
if (dma->waiting) {
|
|
dma->waiting = FALSE;
|
|
complete(&dma->comp);
|
|
}
|
|
}
|
|
#ifndef CONFIG_FB_MSM_MDP22
|
|
if (mdp_interrupt & MDP_HIST_DONE) {
|
|
outp32(MDP_BASE + 0x94018, 0x3);
|
|
outp32(MDP_INTR_CLEAR, MDP_HIST_DONE);
|
|
if (mdp_hist.r)
|
|
memcpy(mdp_hist.r, MDP_BASE + 0x94100,
|
|
mdp_hist.bin_cnt*4);
|
|
if (mdp_hist.g)
|
|
memcpy(mdp_hist.g, MDP_BASE + 0x94200,
|
|
mdp_hist.bin_cnt*4);
|
|
if (mdp_hist.b)
|
|
memcpy(mdp_hist.b, MDP_BASE + 0x94300,
|
|
mdp_hist.bin_cnt*4);
|
|
complete(&mdp_hist_comp);
|
|
}
|
|
|
|
/* LCDC UnderFlow */
|
|
if (mdp_interrupt & LCDC_UNDERFLOW) {
|
|
mdp_lcdc_underflow_cnt++;
|
|
}
|
|
/* LCDC Frame Start */
|
|
if (mdp_interrupt & LCDC_FRAME_START) {
|
|
/* let's disable LCDC interrupt */
|
|
mdp_intr_mask &= ~LCDC_FRAME_START;
|
|
outp32(MDP_INTR_ENABLE, mdp_intr_mask);
|
|
|
|
dma = &dma2_data;
|
|
if (dma->waiting) {
|
|
dma->waiting = FALSE;
|
|
complete(&dma->comp);
|
|
}
|
|
}
|
|
|
|
/* DMA2 LCD-Out Complete */
|
|
if (mdp_interrupt & MDP_DMA_S_DONE) {
|
|
dma = &dma_s_data;
|
|
dma->busy = FALSE;
|
|
mdp_pipe_ctrl(MDP_DMA_S_BLOCK, MDP_BLOCK_POWER_OFF,
|
|
TRUE);
|
|
complete(&dma->comp);
|
|
}
|
|
#endif
|
|
|
|
/* DMA2 LCD-Out Complete */
|
|
if (mdp_interrupt & MDP_DMA_P_DONE) {
|
|
struct timeval now;
|
|
ktime_t now_k;
|
|
|
|
now_k = ktime_get_real();
|
|
mdp_dma2_last_update_time.tv.sec =
|
|
now_k.tv.sec - mdp_dma2_last_update_time.tv.sec;
|
|
mdp_dma2_last_update_time.tv.nsec =
|
|
now_k.tv.nsec - mdp_dma2_last_update_time.tv.nsec;
|
|
|
|
if (mdp_debug[MDP_DMA2_BLOCK]) {
|
|
jiffies_to_timeval(jiffies, &now);
|
|
mdp_dma2_timeval.tv_usec =
|
|
now.tv_usec - mdp_dma2_timeval.tv_usec;
|
|
}
|
|
|
|
dma = &dma2_data;
|
|
dma->busy = FALSE;
|
|
mdp_pipe_ctrl(MDP_DMA2_BLOCK, MDP_BLOCK_POWER_OFF,
|
|
TRUE);
|
|
complete(&dma->comp);
|
|
}
|
|
/* PPP Complete */
|
|
if (mdp_interrupt & MDP_PPP_DONE) {
|
|
#ifdef CONFIG_MDP_PPP_ASYNC_OP
|
|
mdp_ppp_djob_done();
|
|
#else
|
|
mdp_pipe_ctrl(MDP_PPP_BLOCK,
|
|
MDP_BLOCK_POWER_OFF, TRUE);
|
|
if (mdp_ppp_waiting) {
|
|
mdp_ppp_waiting = FALSE;
|
|
complete(&mdp_ppp_comp);
|
|
}
|
|
#endif
|
|
}
|
|
} while (1);
|
|
|
|
mdp_is_in_isr = FALSE;
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
#endif
|
|
|
|
static void mdp_drv_init(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MDP_MAX_BLOCK; i++) {
|
|
mdp_debug[i] = 0;
|
|
}
|
|
|
|
/* initialize spin lock and workqueue */
|
|
spin_lock_init(&mdp_spin_lock);
|
|
mdp_dma_wq = create_singlethread_workqueue("mdp_dma_wq");
|
|
mdp_vsync_wq = create_singlethread_workqueue("mdp_vsync_wq");
|
|
mdp_pipe_ctrl_wq = create_singlethread_workqueue("mdp_pipe_ctrl_wq");
|
|
INIT_DELAYED_WORK(&mdp_pipe_ctrl_worker,
|
|
mdp_pipe_ctrl_workqueue_handler);
|
|
#ifdef CONFIG_MDP_PPP_ASYNC_OP
|
|
mdp_ppp_dq_init();
|
|
#endif
|
|
|
|
/* initialize semaphore */
|
|
init_completion(&mdp_ppp_comp);
|
|
init_MUTEX(&mdp_ppp_mutex);
|
|
init_MUTEX(&mdp_pipe_ctrl_mutex);
|
|
|
|
dma2_data.busy = FALSE;
|
|
dma2_data.waiting = FALSE;
|
|
init_completion(&dma2_data.comp);
|
|
init_MUTEX(&dma2_data.mutex);
|
|
mutex_init(&dma2_data.ov_mutex);
|
|
|
|
dma3_data.busy = FALSE;
|
|
dma3_data.waiting = FALSE;
|
|
init_completion(&dma3_data.comp);
|
|
init_MUTEX(&dma3_data.mutex);
|
|
|
|
dma_s_data.busy = FALSE;
|
|
dma_s_data.waiting = FALSE;
|
|
init_completion(&dma_s_data.comp);
|
|
init_MUTEX(&dma_s_data.mutex);
|
|
|
|
dma_e_data.busy = FALSE;
|
|
dma_e_data.waiting = FALSE;
|
|
init_completion(&dma_e_data.comp);
|
|
|
|
#ifndef CONFIG_FB_MSM_MDP22
|
|
init_completion(&mdp_hist_comp);
|
|
#endif
|
|
|
|
/* initializing mdp power block counter to 0 */
|
|
for (i = 0; i < MDP_MAX_BLOCK; i++) {
|
|
mdp_block_power_cnt[i] = 0;
|
|
}
|
|
|
|
#ifdef MSM_FB_ENABLE_DBGFS
|
|
{
|
|
struct dentry *root;
|
|
char sub_name[] = "mdp";
|
|
|
|
root = msm_fb_get_debugfs_root();
|
|
if (root != NULL) {
|
|
mdp_dir = debugfs_create_dir(sub_name, root);
|
|
|
|
if (mdp_dir) {
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"dma2_update_time_in_usec",
|
|
(u32 *) &mdp_dma2_update_time_in_usec);
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"vs_rdcnt_slow",
|
|
(u32 *) &mdp_lcd_rd_cnt_offset_slow);
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"vs_rdcnt_fast",
|
|
(u32 *) &mdp_lcd_rd_cnt_offset_fast);
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"mdp_usec_diff_threshold",
|
|
(u32 *) &mdp_usec_diff_threshold);
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"mdp_current_clk_on",
|
|
(u32 *) &mdp_current_clk_on);
|
|
#ifdef CONFIG_FB_MSM_LCDC
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"lcdc_start_x",
|
|
(u32 *) &first_pixel_start_x);
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"lcdc_start_y",
|
|
(u32 *) &first_pixel_start_y);
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"mdp_lcdc_pclk_clk_rate",
|
|
(u32 *) &mdp_lcdc_pclk_clk_rate);
|
|
msm_fb_debugfs_file_create(mdp_dir,
|
|
"mdp_lcdc_pad_pclk_clk_rate",
|
|
(u32 *) &mdp_lcdc_pad_pclk_clk_rate);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static int mdp_probe(struct platform_device *pdev);
|
|
static int mdp_remove(struct platform_device *pdev);
|
|
|
|
static struct platform_driver mdp_driver = {
|
|
.probe = mdp_probe,
|
|
.remove = mdp_remove,
|
|
#ifndef CONFIG_HAS_EARLYSUSPEND
|
|
.suspend = mdp_suspend,
|
|
.resume = NULL,
|
|
#endif
|
|
.shutdown = NULL,
|
|
.driver = {
|
|
/*
|
|
* Driver name must match the device name added in
|
|
* platform.c.
|
|
*/
|
|
.name = "mdp",
|
|
},
|
|
};
|
|
|
|
static int mdp_off(struct platform_device *pdev)
|
|
{
|
|
int ret = 0;
|
|
|
|
#ifdef MDP_HW_VSYNC
|
|
struct msm_fb_data_type *mfd = platform_get_drvdata(pdev);
|
|
#endif
|
|
|
|
ret = panel_next_off(pdev);
|
|
|
|
#ifdef MDP_HW_VSYNC
|
|
mdp_hw_vsync_clk_disable(mfd);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int mdp_on(struct platform_device *pdev)
|
|
{
|
|
#ifdef MDP_HW_VSYNC
|
|
struct msm_fb_data_type *mfd = platform_get_drvdata(pdev);
|
|
#endif
|
|
|
|
int ret = 0;
|
|
|
|
#ifdef MDP_HW_VSYNC
|
|
mdp_hw_vsync_clk_enable(mfd);
|
|
#endif
|
|
|
|
ret = panel_next_on(pdev);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int mdp_irq_clk_setup(void)
|
|
{
|
|
int ret;
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
ret = request_irq(INT_MDP, mdp4_isr, IRQF_DISABLED, "MDP", 0);
|
|
#else
|
|
ret = request_irq(INT_MDP, mdp_isr, IRQF_DISABLED, "MDP", 0);
|
|
#endif
|
|
if (ret) {
|
|
printk(KERN_ERR "mdp request_irq() failed!\n");
|
|
return ret;
|
|
}
|
|
disable_irq(INT_MDP);
|
|
|
|
mdp_clk = clk_get(NULL, "mdp_clk");
|
|
|
|
if (IS_ERR(mdp_clk)) {
|
|
ret = PTR_ERR(mdp_clk);
|
|
printk(KERN_ERR "can't get mdp_clk error:%d!\n", ret);
|
|
free_irq(INT_MDP, 0);
|
|
return ret;
|
|
}
|
|
|
|
mdp_pclk = clk_get(NULL, "mdp_pclk");
|
|
if (IS_ERR(mdp_pclk))
|
|
mdp_pclk = NULL;
|
|
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
/*
|
|
* mdp_clk should greater than mdp_pclk always
|
|
*/
|
|
clk_set_rate(mdp_clk, 122880000); /* 122.88 Mhz */
|
|
printk(KERN_INFO "mdp_clk: mdp_clk=%d mdp_pclk=%d\n",
|
|
(int)clk_get_rate(mdp_clk), (int)clk_get_rate(mdp_pclk));
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_device *pdev_list[MSM_FB_MAX_DEV_LIST];
|
|
static int pdev_list_cnt;
|
|
static int mdp_resource_initialized;
|
|
static struct msm_panel_common_pdata *mdp_pdata;
|
|
|
|
static int mdp_probe(struct platform_device *pdev)
|
|
{
|
|
struct platform_device *msm_fb_dev = NULL;
|
|
struct msm_fb_data_type *mfd;
|
|
struct msm_fb_panel_data *pdata = NULL;
|
|
int rc;
|
|
resource_size_t size ;
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
int intf, if_no;
|
|
#else
|
|
unsigned long flag;
|
|
#endif
|
|
|
|
if ((pdev->id == 0) && (pdev->num_resources > 0)) {
|
|
mdp_pdata = pdev->dev.platform_data;
|
|
|
|
size = resource_size(&pdev->resource[0]);
|
|
msm_mdp_base = ioremap(pdev->resource[0].start, size);
|
|
|
|
MSM_FB_INFO("MDP HW Base phy_Address = 0x%x virt = 0x%x\n",
|
|
(int)pdev->resource[0].start, (int)msm_mdp_base);
|
|
|
|
if (unlikely(!msm_mdp_base))
|
|
return -ENOMEM;
|
|
|
|
printk("irq clk setup\n");
|
|
rc = mdp_irq_clk_setup();
|
|
printk("irq clk setup done\n");
|
|
if (rc)
|
|
return rc;
|
|
|
|
/* initializing mdp hw */
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
mdp4_hw_init();
|
|
#else
|
|
mdp_hw_init();
|
|
#endif
|
|
|
|
mdp_resource_initialized = 1;
|
|
return 0;
|
|
}
|
|
|
|
if (!mdp_resource_initialized)
|
|
return -EPERM;
|
|
|
|
mfd = platform_get_drvdata(pdev);
|
|
|
|
if (!mfd)
|
|
return -ENODEV;
|
|
|
|
if (mfd->key != MFD_KEY)
|
|
return -EINVAL;
|
|
|
|
if (pdev_list_cnt >= MSM_FB_MAX_DEV_LIST)
|
|
return -ENOMEM;
|
|
|
|
msm_fb_dev = platform_device_alloc("msm_fb", pdev->id);
|
|
if (!msm_fb_dev)
|
|
return -ENOMEM;
|
|
|
|
/* link to the latest pdev */
|
|
mfd->pdev = msm_fb_dev;
|
|
|
|
/* add panel data */
|
|
if (platform_device_add_data
|
|
(msm_fb_dev, pdev->dev.platform_data,
|
|
sizeof(struct msm_fb_panel_data))) {
|
|
printk(KERN_ERR "mdp_probe: platform_device_add_data failed!\n");
|
|
rc = -ENOMEM;
|
|
goto mdp_probe_err;
|
|
}
|
|
/* data chain */
|
|
pdata = msm_fb_dev->dev.platform_data;
|
|
pdata->on = mdp_on;
|
|
pdata->off = mdp_off;
|
|
pdata->next = pdev;
|
|
|
|
switch (mfd->panel.type) {
|
|
case EXT_MDDI_PANEL:
|
|
case MDDI_PANEL:
|
|
case EBI2_PANEL:
|
|
INIT_WORK(&mfd->dma_update_worker,
|
|
mdp_lcd_update_workqueue_handler);
|
|
INIT_WORK(&mfd->vsync_resync_worker,
|
|
mdp_vsync_resync_workqueue_handler);
|
|
mfd->hw_refresh = FALSE;
|
|
|
|
if (mfd->panel.type == EXT_MDDI_PANEL) {
|
|
/* 15 fps -> 66 msec */
|
|
mfd->refresh_timer_duration = (66 * HZ / 1000);
|
|
} else {
|
|
/* 24 fps -> 42 msec */
|
|
mfd->refresh_timer_duration = (42 * HZ / 1000);
|
|
}
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP22
|
|
mfd->dma_fnc = mdp_dma2_update;
|
|
mfd->dma = &dma2_data;
|
|
#else
|
|
if (mfd->panel_info.pdest == DISPLAY_1) {
|
|
#ifdef CONFIG_FB_MSM_OVERLAY
|
|
mfd->dma_fnc = mdp4_mddi_overlay;
|
|
#else
|
|
mfd->dma_fnc = mdp_dma2_update;
|
|
#endif
|
|
mfd->dma = &dma2_data;
|
|
mfd->lut_update = mdp_lut_update_nonlcdc;
|
|
mfd->do_histogram = mdp_do_histogram;
|
|
} else {
|
|
mfd->dma_fnc = mdp_dma_s_update;
|
|
mfd->dma = &dma_s_data;
|
|
}
|
|
#endif
|
|
if (mdp_pdata)
|
|
mfd->vsync_gpio = mdp_pdata->gpio;
|
|
else
|
|
mfd->vsync_gpio = -1;
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
if (mfd->panel.type == EBI2_PANEL)
|
|
intf = EBI2_INTF;
|
|
else
|
|
intf = MDDI_INTF;
|
|
|
|
if (mfd->panel_info.pdest == DISPLAY_1)
|
|
if_no = PRIMARY_INTF_SEL;
|
|
else
|
|
if_no = SECONDARY_INTF_SEL;
|
|
|
|
mdp4_display_intf_sel(if_no, intf);
|
|
#endif
|
|
mdp_config_vsync(mfd);
|
|
break;
|
|
|
|
case HDMI_PANEL:
|
|
case LCDC_PANEL:
|
|
pdata->on = mdp_lcdc_on;
|
|
pdata->off = mdp_lcdc_off;
|
|
mfd->hw_refresh = TRUE;
|
|
mfd->cursor_update = mdp_hw_cursor_update;
|
|
#ifndef CONFIG_FB_MSM_MDP22
|
|
mfd->lut_update = mdp_lut_update_lcdc;
|
|
mfd->do_histogram = mdp_do_histogram;
|
|
#endif
|
|
#ifdef CONFIG_FB_MSM_OVERLAY
|
|
mfd->dma_fnc = mdp4_lcdc_overlay;
|
|
#else
|
|
mfd->dma_fnc = mdp_lcdc_update;
|
|
#endif
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
if (mfd->panel.type == HDMI_PANEL) {
|
|
mfd->dma = &dma_e_data;
|
|
mdp4_display_intf_sel(EXTERNAL_INTF_SEL, LCDC_RGB_INTF);
|
|
} else {
|
|
mfd->dma = &dma2_data;
|
|
mdp4_display_intf_sel(PRIMARY_INTF_SEL, LCDC_RGB_INTF);
|
|
}
|
|
#else
|
|
mfd->dma = &dma2_data;
|
|
spin_lock_irqsave(&mdp_spin_lock, flag);
|
|
mdp_intr_mask &= ~MDP_DMA_P_DONE;
|
|
outp32(MDP_INTR_ENABLE, mdp_intr_mask);
|
|
spin_unlock_irqrestore(&mdp_spin_lock, flag);
|
|
#endif
|
|
break;
|
|
|
|
case TV_PANEL:
|
|
pdata->on = mdp_dma3_on;
|
|
pdata->off = mdp_dma3_off;
|
|
mfd->hw_refresh = TRUE;
|
|
mfd->dma_fnc = mdp_dma3_update;
|
|
mfd->dma = &dma3_data;
|
|
break;
|
|
|
|
default:
|
|
printk(KERN_ERR "mdp_probe: unknown device type!\n");
|
|
rc = -ENODEV;
|
|
goto mdp_probe_err;
|
|
}
|
|
|
|
/* set driver data */
|
|
platform_set_drvdata(msm_fb_dev, mfd);
|
|
|
|
rc = platform_device_add(msm_fb_dev);
|
|
if (rc) {
|
|
goto mdp_probe_err;
|
|
}
|
|
|
|
pdev_list[pdev_list_cnt++] = pdev;
|
|
return 0;
|
|
|
|
mdp_probe_err:
|
|
platform_device_put(msm_fb_dev);
|
|
return rc;
|
|
}
|
|
|
|
static void mdp_suspend_sub(void)
|
|
{
|
|
/* cancel pipe ctrl worker */
|
|
cancel_delayed_work(&mdp_pipe_ctrl_worker);
|
|
|
|
/* for workder can't be cancelled... */
|
|
flush_workqueue(mdp_pipe_ctrl_wq);
|
|
|
|
/* let's wait for PPP completion */
|
|
while (mdp_block_power_cnt[MDP_PPP_BLOCK] > 0) ;
|
|
|
|
/* try to power down */
|
|
mdp_pipe_ctrl(MDP_MASTER_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
|
|
}
|
|
|
|
#if defined(CONFIG_PM) && !defined(CONFIG_HAS_EARLYSUSPEND)
|
|
static int mdp_suspend(struct platform_device *pdev, pm_message_t state)
|
|
{
|
|
mdp_suspend_sub();
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_HAS_EARLYSUSPEND
|
|
static void mdp_early_suspend(struct early_suspend *h)
|
|
{
|
|
mdp_suspend_sub();
|
|
}
|
|
#endif
|
|
|
|
static int mdp_remove(struct platform_device *pdev)
|
|
{
|
|
iounmap(msm_mdp_base);
|
|
return 0;
|
|
}
|
|
|
|
static int mdp_register_driver(void)
|
|
{
|
|
#ifdef CONFIG_HAS_EARLYSUSPEND
|
|
early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1;
|
|
early_suspend.suspend = mdp_early_suspend;
|
|
register_early_suspend(&early_suspend);
|
|
#endif
|
|
|
|
return platform_driver_register(&mdp_driver);
|
|
}
|
|
|
|
static int __init mdp_driver_init(void)
|
|
{
|
|
int ret;
|
|
|
|
mdp_drv_init();
|
|
|
|
ret = mdp_register_driver();
|
|
if (ret) {
|
|
printk(KERN_ERR "mdp_register_driver() failed!\n");
|
|
return ret;
|
|
}
|
|
|
|
#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_FB_MSM_MDP40)
|
|
mdp4_debugfs_init();
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
module_init(mdp_driver_init);
|