![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>
390 lines
10 KiB
C
390 lines
10 KiB
C
/* Copyright (c) 2008-2009, 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/vmalloc.h>
|
|
#include <linux/clk.h>
|
|
|
|
#include <mach/hardware.h>
|
|
#include <linux/io.h>
|
|
|
|
#include <asm/system.h>
|
|
#include <asm/mach-types.h>
|
|
#include <linux/semaphore.h>
|
|
#include <linux/uaccess.h>
|
|
#include <mach/gpio.h>
|
|
|
|
#include "mdp.h"
|
|
#include "msm_fb.h"
|
|
#include "mddihost.h"
|
|
|
|
#ifdef CONFIG_FB_MSM_MDP40
|
|
#define MDP_SYNC_CFG_0 0x100
|
|
#define MDP_SYNC_STATUS_0 0x10c
|
|
#define MDP_PRIM_VSYNC_OUT_CTRL 0x118
|
|
#define MDP_PRIM_VSYNC_INIT_VAL 0x128
|
|
#else
|
|
#define MDP_SYNC_CFG_0 0x300
|
|
#define MDP_SYNC_STATUS_0 0x30c
|
|
#define MDP_PRIM_VSYNC_OUT_CTRL 0x318
|
|
#define MDP_PRIM_VSYNC_INIT_VAL 0x328
|
|
#endif
|
|
|
|
extern mddi_lcd_type mddi_lcd_idx;
|
|
extern spinlock_t mdp_spin_lock;
|
|
extern struct workqueue_struct *mdp_vsync_wq;
|
|
extern int lcdc_mode;
|
|
extern int vsync_mode;
|
|
|
|
#ifdef MDP_HW_VSYNC
|
|
int vsync_above_th = 4;
|
|
int vsync_start_th = 1;
|
|
int vsync_load_cnt;
|
|
|
|
struct clk *mdp_vsync_clk;
|
|
|
|
void mdp_hw_vsync_clk_enable(struct msm_fb_data_type *mfd)
|
|
{
|
|
if (mfd->use_mdp_vsync)
|
|
clk_enable(mdp_vsync_clk);
|
|
}
|
|
|
|
void mdp_hw_vsync_clk_disable(struct msm_fb_data_type *mfd)
|
|
{
|
|
if (mfd->use_mdp_vsync)
|
|
clk_disable(mdp_vsync_clk);
|
|
}
|
|
#endif
|
|
|
|
static void mdp_set_vsync(unsigned long data)
|
|
{
|
|
struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)data;
|
|
struct msm_fb_panel_data *pdata = NULL;
|
|
|
|
pdata = (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data;
|
|
|
|
if ((pdata) && (pdata->set_vsync_notifier == NULL))
|
|
return;
|
|
|
|
init_timer(&mfd->vsync_resync_timer);
|
|
mfd->vsync_resync_timer.function = mdp_set_vsync;
|
|
mfd->vsync_resync_timer.data = data;
|
|
mfd->vsync_resync_timer.expires =
|
|
jiffies + mfd->panel_info.lcd.vsync_notifier_period;
|
|
add_timer(&mfd->vsync_resync_timer);
|
|
|
|
if ((mfd->panel_info.lcd.vsync_enable) && (mfd->panel_power_on)
|
|
&& (!mfd->vsync_handler_pending)) {
|
|
mfd->vsync_handler_pending = TRUE;
|
|
if (!queue_work(mdp_vsync_wq, &mfd->vsync_resync_worker)) {
|
|
MSM_FB_INFO
|
|
("mdp_set_vsync: can't queue_work! -> needs to increase vsync_resync_timer_duration\n");
|
|
}
|
|
} else {
|
|
MSM_FB_DEBUG
|
|
("mdp_set_vsync failed! EN:%d PWR:%d PENDING:%d\n",
|
|
mfd->panel_info.lcd.vsync_enable, mfd->panel_power_on,
|
|
mfd->vsync_handler_pending);
|
|
}
|
|
}
|
|
|
|
static void mdp_vsync_handler(void *data)
|
|
{
|
|
struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)data;
|
|
|
|
if (mfd->use_mdp_vsync) {
|
|
#ifdef MDP_HW_VSYNC
|
|
if (mfd->panel_power_on)
|
|
MDP_OUTP(MDP_BASE + MDP_SYNC_STATUS_0, vsync_load_cnt);
|
|
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, TRUE);
|
|
#endif
|
|
} else {
|
|
mfd->last_vsync_timetick = ktime_get_real();
|
|
}
|
|
|
|
mfd->vsync_handler_pending = FALSE;
|
|
}
|
|
|
|
irqreturn_t mdp_hw_vsync_handler_proxy(int irq, void *data)
|
|
{
|
|
/*
|
|
* ToDo: tried enabling/disabling GPIO MDP HW VSYNC interrupt
|
|
* but getting inaccurate timing in mdp_vsync_handler()
|
|
* disable_irq(MDP_HW_VSYNC_IRQ);
|
|
*/
|
|
mdp_vsync_handler(data);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
#ifdef MDP_HW_VSYNC
|
|
static void mdp_set_sync_cfg_0(struct msm_fb_data_type *mfd, int vsync_cnt)
|
|
{
|
|
unsigned long cfg;
|
|
|
|
cfg = mfd->total_lcd_lines - 1;
|
|
cfg <<= MDP_SYNCFG_HGT_LOC;
|
|
if (mfd->panel_info.lcd.hw_vsync_mode)
|
|
cfg |= MDP_SYNCFG_VSYNC_EXT_EN;
|
|
cfg |= (MDP_SYNCFG_VSYNC_INT_EN | vsync_cnt);
|
|
|
|
MDP_OUTP(MDP_BASE + MDP_SYNC_CFG_0, cfg);
|
|
}
|
|
#endif
|
|
|
|
void mdp_config_vsync(struct msm_fb_data_type *mfd)
|
|
{
|
|
|
|
/* vsync on primary lcd only for now */
|
|
if ((mfd->dest != DISPLAY_LCD) || (mfd->panel_info.pdest != DISPLAY_1)
|
|
|| (!vsync_mode)) {
|
|
goto err_handle;
|
|
}
|
|
|
|
if (mfd->panel_info.lcd.vsync_enable) {
|
|
mfd->total_porch_lines = mfd->panel_info.lcd.v_back_porch +
|
|
mfd->panel_info.lcd.v_front_porch +
|
|
mfd->panel_info.lcd.v_pulse_width;
|
|
mfd->total_lcd_lines =
|
|
mfd->panel_info.yres + mfd->total_porch_lines;
|
|
mfd->lcd_ref_usec_time =
|
|
100000000 / mfd->panel_info.lcd.refx100;
|
|
mfd->vsync_handler_pending = FALSE;
|
|
mfd->last_vsync_timetick.tv.sec = 0;
|
|
mfd->last_vsync_timetick.tv.nsec = 0;
|
|
|
|
#ifdef MDP_HW_VSYNC
|
|
if (mdp_vsync_clk == NULL)
|
|
mdp_vsync_clk = clk_get(NULL, "mdp_vsync_clk");
|
|
|
|
if (IS_ERR(mdp_vsync_clk)) {
|
|
printk(KERN_ERR "error: can't get mdp_vsync_clk!\n");
|
|
mfd->use_mdp_vsync = 0;
|
|
} else
|
|
mfd->use_mdp_vsync = 1;
|
|
|
|
if (mfd->use_mdp_vsync) {
|
|
uint32 vsync_cnt_cfg, vsync_cnt_cfg_dem;
|
|
uint32 mdp_vsync_clk_speed_hz;
|
|
|
|
mdp_vsync_clk_speed_hz = clk_get_rate(mdp_vsync_clk);
|
|
|
|
if (mdp_vsync_clk_speed_hz == 0) {
|
|
mfd->use_mdp_vsync = 0;
|
|
} else {
|
|
/*
|
|
* Do this calculation in 2 steps for
|
|
* rounding uint32 properly.
|
|
*/
|
|
vsync_cnt_cfg_dem =
|
|
(mfd->panel_info.lcd.refx100 *
|
|
mfd->total_lcd_lines) / 100;
|
|
vsync_cnt_cfg =
|
|
(mdp_vsync_clk_speed_hz) /
|
|
vsync_cnt_cfg_dem;
|
|
|
|
/* MDP cmd block enable */
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON,
|
|
FALSE);
|
|
mdp_hw_vsync_clk_enable(mfd);
|
|
|
|
mdp_set_sync_cfg_0(mfd, vsync_cnt_cfg);
|
|
|
|
/*
|
|
* load the last line + 1 to be in the
|
|
* safety zone
|
|
*/
|
|
vsync_load_cnt = mfd->panel_info.yres;
|
|
|
|
/* line counter init value at the next pulse */
|
|
MDP_OUTP(MDP_BASE + MDP_PRIM_VSYNC_INIT_VAL,
|
|
vsync_load_cnt);
|
|
|
|
/*
|
|
* external vsync source pulse width and
|
|
* polarity flip
|
|
*/
|
|
MDP_OUTP(MDP_BASE + MDP_PRIM_VSYNC_OUT_CTRL,
|
|
BIT(30) | BIT(0));
|
|
|
|
|
|
/* threshold */
|
|
MDP_OUTP(MDP_BASE + 0x200,
|
|
(vsync_above_th << 16) |
|
|
(vsync_start_th));
|
|
|
|
mdp_hw_vsync_clk_disable(mfd);
|
|
/* MDP cmd block disable */
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK,
|
|
MDP_BLOCK_POWER_OFF, FALSE);
|
|
}
|
|
}
|
|
#else
|
|
mfd->use_mdp_vsync = 0;
|
|
hrtimer_init(&mfd->dma_hrtimer, CLOCK_MONOTONIC,
|
|
HRTIMER_MODE_REL);
|
|
mfd->dma_hrtimer.function = mdp_dma2_vsync_hrtimer_handler;
|
|
mfd->vsync_width_boundary = vmalloc(mfd->panel_info.xres * 4);
|
|
#endif
|
|
|
|
mfd->channel_irq = 0;
|
|
if (mfd->panel_info.lcd.hw_vsync_mode) {
|
|
u32 vsync_gpio = mfd->vsync_gpio;
|
|
u32 ret;
|
|
|
|
if (vsync_gpio == -1) {
|
|
MSM_FB_INFO("vsync_gpio not defined!\n");
|
|
goto err_handle;
|
|
}
|
|
|
|
ret = gpio_tlmm_config(GPIO_CFG
|
|
(vsync_gpio,
|
|
(mfd->use_mdp_vsync) ? 1 : 0,
|
|
GPIO_INPUT,
|
|
GPIO_PULL_DOWN,
|
|
GPIO_2MA),
|
|
GPIO_ENABLE);
|
|
if (ret)
|
|
goto err_handle;
|
|
|
|
if (!mfd->use_mdp_vsync) {
|
|
mfd->channel_irq = MSM_GPIO_TO_INT(vsync_gpio);
|
|
if (request_irq
|
|
(mfd->channel_irq,
|
|
&mdp_hw_vsync_handler_proxy,
|
|
IRQF_TRIGGER_FALLING, "VSYNC_GPIO",
|
|
(void *)mfd)) {
|
|
MSM_FB_INFO
|
|
("irq=%d failed! vsync_gpio=%d\n",
|
|
mfd->channel_irq,
|
|
vsync_gpio);
|
|
goto err_handle;
|
|
}
|
|
}
|
|
}
|
|
|
|
mdp_set_vsync((unsigned long)mfd);
|
|
}
|
|
|
|
return;
|
|
|
|
err_handle:
|
|
if (mfd->vsync_width_boundary)
|
|
vfree(mfd->vsync_width_boundary);
|
|
mfd->panel_info.lcd.vsync_enable = FALSE;
|
|
printk(KERN_ERR "%s: failed!\n", __func__);
|
|
}
|
|
|
|
void mdp_vsync_resync_workqueue_handler(struct work_struct *work)
|
|
{
|
|
struct msm_fb_data_type *mfd = NULL;
|
|
int vsync_fnc_enabled = FALSE;
|
|
struct msm_fb_panel_data *pdata = NULL;
|
|
|
|
mfd = container_of(work, struct msm_fb_data_type, vsync_resync_worker);
|
|
|
|
if (mfd) {
|
|
if (mfd->panel_power_on) {
|
|
pdata =
|
|
(struct msm_fb_panel_data *)mfd->pdev->dev.
|
|
platform_data;
|
|
|
|
/*
|
|
* we need to turn on MDP power if it uses MDP vsync
|
|
* HW block in SW mode
|
|
*/
|
|
if ((!mfd->panel_info.lcd.hw_vsync_mode) &&
|
|
(mfd->use_mdp_vsync) &&
|
|
(pdata) && (pdata->set_vsync_notifier != NULL)) {
|
|
/*
|
|
* enable pwr here since we can't enable it in
|
|
* vsync callback in isr mode
|
|
*/
|
|
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON,
|
|
FALSE);
|
|
}
|
|
|
|
if (pdata->set_vsync_notifier != NULL) {
|
|
vsync_fnc_enabled = TRUE;
|
|
pdata->set_vsync_notifier(mdp_vsync_handler,
|
|
(void *)mfd);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((mfd) && (!vsync_fnc_enabled))
|
|
mfd->vsync_handler_pending = FALSE;
|
|
}
|
|
|
|
boolean mdp_hw_vsync_set_handler(msm_fb_vsync_handler_type handler, void *data)
|
|
{
|
|
/*
|
|
* ToDo: tried enabling/disabling GPIO MDP HW VSYNC interrupt
|
|
* but getting inaccurate timing in mdp_vsync_handler()
|
|
* enable_irq(MDP_HW_VSYNC_IRQ);
|
|
*/
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
uint32 mdp_get_lcd_line_counter(struct msm_fb_data_type *mfd)
|
|
{
|
|
uint32 elapsed_usec_time;
|
|
uint32 lcd_line;
|
|
ktime_t last_vsync_timetick_local;
|
|
ktime_t curr_time;
|
|
unsigned long flag;
|
|
|
|
if ((!mfd->panel_info.lcd.vsync_enable) || (!vsync_mode))
|
|
return 0;
|
|
|
|
spin_lock_irqsave(&mdp_spin_lock, flag);
|
|
last_vsync_timetick_local = mfd->last_vsync_timetick;
|
|
spin_unlock_irqrestore(&mdp_spin_lock, flag);
|
|
|
|
curr_time = ktime_get_real();
|
|
elapsed_usec_time =
|
|
((curr_time.tv.sec - last_vsync_timetick_local.tv.sec) * 1000000) +
|
|
((curr_time.tv.nsec - last_vsync_timetick_local.tv.nsec) / 1000);
|
|
|
|
elapsed_usec_time = elapsed_usec_time % mfd->lcd_ref_usec_time;
|
|
|
|
/* lcd line calculation referencing to line counter = 0 */
|
|
lcd_line =
|
|
(elapsed_usec_time * mfd->total_lcd_lines) / mfd->lcd_ref_usec_time;
|
|
|
|
/* lcd line adjusment referencing to the actual line counter at vsync */
|
|
lcd_line =
|
|
(mfd->total_lcd_lines - mfd->panel_info.lcd.v_back_porch +
|
|
lcd_line) % (mfd->total_lcd_lines + 1);
|
|
|
|
if (lcd_line > mfd->total_lcd_lines) {
|
|
MSM_FB_INFO
|
|
("mdp_get_lcd_line_counter: mdp_lcd_rd_cnt >= mfd->total_lcd_lines error!\n");
|
|
}
|
|
|
|
return lcd_line;
|
|
}
|