[mirror_ubuntu-artful-kernel.git] / drivers / staging / msm / mdp_dma_tv.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/hrtimer.h>
#include <linux/delay.h>

#include <mach/hardware.h>
#include <linux/io.h>

#include <asm/system.h>
#include <asm/mach-types.h>
#include <linux/semaphore.h>
#include <linux/spinlock.h>

#include <linux/fb.h>

#include "mdp.h"
#include "msm_fb.h"

extern spinlock_t mdp_spin_lock;
extern uint32 mdp_intr_mask;

int mdp_dma3_on(struct platform_device *pdev)
{
	struct msm_fb_data_type *mfd;
	struct fb_info *fbi;
	uint8 *buf;
	int bpp;
	int ret = 0;

	mfd = (struct msm_fb_data_type *)platform_get_drvdata(pdev);

	if (!mfd)
		return -ENODEV;

	if (mfd->key != MFD_KEY)
		return -EINVAL;

	fbi = mfd->fbi;
	/* MDP cmd block enable */
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);

	bpp = fbi->var.bits_per_pixel / 8;
	buf = (uint8 *) fbi->fix.smem_start;
	buf += fbi->var.xoffset * bpp +
		fbi->var.yoffset * fbi->fix.line_length;

	/* starting address[31..8] of Video frame buffer is CS0 */
	MDP_OUTP(MDP_BASE + 0xC0008, (uint32) buf >> 3);

	mdp_pipe_ctrl(MDP_DMA3_BLOCK, MDP_BLOCK_POWER_ON, FALSE);

	MDP_OUTP(MDP_BASE + 0xC0004, 0x4c60674); /* flicker filter enabled */
	MDP_OUTP(MDP_BASE + 0xC0010, 0x20);	/* sobel treshold */

	MDP_OUTP(MDP_BASE + 0xC0018, 0xeb0010);	/* Y  Max, Y  min */
	MDP_OUTP(MDP_BASE + 0xC001C, 0xf00010);	/* Cb Max, Cb min */
	MDP_OUTP(MDP_BASE + 0xC0020, 0xf00010);	/* Cb Max, Cb min */

	MDP_OUTP(MDP_BASE + 0xC000C, 0x67686970); /* add a few chars for CC */
	MDP_OUTP(MDP_BASE + 0xC0000, 0x1);	/* MDP tv out enable */

	/* MDP cmd block disable */
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);

	ret = panel_next_on(pdev);

	return ret;
}

int mdp_dma3_off(struct platform_device *pdev)
{
	int ret = 0;

	ret = panel_next_off(pdev);
	if (ret)
		return ret;

	/* MDP cmd block enable */
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
	MDP_OUTP(MDP_BASE + 0xC0000, 0x0);
	/* MDP cmd block disable */
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);

	mdp_pipe_ctrl(MDP_DMA3_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);

	/* delay to make sure the last frame finishes */
	mdelay(100);

	return ret;
}

void mdp_dma3_update(struct msm_fb_data_type *mfd)
{
	struct fb_info *fbi = mfd->fbi;
	uint8 *buf;
	int bpp;
	unsigned long flag;

	if (!mfd->panel_power_on)
		return;

	/* no need to power on cmd block since dma3 is running */
	bpp = fbi->var.bits_per_pixel / 8;
	buf = (uint8 *) fbi->fix.smem_start;
	buf += fbi->var.xoffset * bpp +
		fbi->var.yoffset * fbi->fix.line_length;
	MDP_OUTP(MDP_BASE + 0xC0008, (uint32) buf >> 3);

	spin_lock_irqsave(&mdp_spin_lock, flag);
	mdp_enable_irq(MDP_DMA3_TERM);
	INIT_COMPLETION(mfd->dma->comp);
	mfd->dma->waiting = TRUE;

	outp32(MDP_INTR_CLEAR, TV_OUT_DMA3_START);
	mdp_intr_mask |= TV_OUT_DMA3_START;
	outp32(MDP_INTR_ENABLE, mdp_intr_mask);
	spin_unlock_irqrestore(&mdp_spin_lock, flag);

	wait_for_completion_killable(&mfd->dma->comp);
	mdp_disable_irq(MDP_DMA3_TERM);
}
Commit	Line	Data
9d200153 SM	1	/* Copyright (c) 2008-2009, Code Aurora Forum. All rights reserved.
	2	*
	3	* This program is free software; you can redistribute it and/or modify
	4	* it under the terms of the GNU General Public License version 2 and
	5	* only version 2 as published by the Free Software Foundation.
	6	*
	7	* This program is distributed in the hope that it will be useful,
	8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	10	* GNU General Public License for more details.
	11	*
	12	* You should have received a copy of the GNU General Public License
	13	* along with this program; if not, write to the Free Software
	14	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	15	* 02110-1301, USA.
	16	*/
	17
	18	#include <linux/module.h>
	19	#include <linux/kernel.h>
	20	#include <linux/sched.h>
	21	#include <linux/time.h>
	22	#include <linux/init.h>
	23	#include <linux/interrupt.h>
	24	#include <linux/hrtimer.h>
	25	#include <linux/delay.h>
	26
	27	#include <mach/hardware.h>
	28	#include <linux/io.h>
	29
	30	#include <asm/system.h>
	31	#include <asm/mach-types.h>
	32	#include <linux/semaphore.h>
	33	#include <linux/spinlock.h>
	34
	35	#include <linux/fb.h>
	36
	37	#include "mdp.h"
	38	#include "msm_fb.h"
	39
	40	extern spinlock_t mdp_spin_lock;
	41	extern uint32 mdp_intr_mask;
	42
	43	int mdp_dma3_on(struct platform_device *pdev)
	44	{
	45	struct msm_fb_data_type *mfd;
	46	struct fb_info *fbi;
	47	uint8 *buf;
	48	int bpp;
	49	int ret = 0;
	50
	51	mfd = (struct msm_fb_data_type *)platform_get_drvdata(pdev);
	52
	53	if (!mfd)
	54	return -ENODEV;
	55
	56	if (mfd->key != MFD_KEY)
	57	return -EINVAL;
	58
	59	fbi = mfd->fbi;
	60	/* MDP cmd block enable */
	61	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
	62
	63	bpp = fbi->var.bits_per_pixel / 8;
	64	buf = (uint8 *) fbi->fix.smem_start;
65	buf += fbi->var.xoffset * bpp +
66	fbi->var.yoffset * fbi->fix.line_length;
67
68	/* starting address[31..8] of Video frame buffer is CS0 */
69	MDP_OUTP(MDP_BASE + 0xC0008, (uint32) buf >> 3);
70
71	mdp_pipe_ctrl(MDP_DMA3_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
72
73	MDP_OUTP(MDP_BASE + 0xC0004, 0x4c60674); /* flicker filter enabled */
74	MDP_OUTP(MDP_BASE + 0xC0010, 0x20); /* sobel treshold */
75
76	MDP_OUTP(MDP_BASE + 0xC0018, 0xeb0010); /* Y Max, Y min */
77	MDP_OUTP(MDP_BASE + 0xC001C, 0xf00010); /* Cb Max, Cb min */
78	MDP_OUTP(MDP_BASE + 0xC0020, 0xf00010); /* Cb Max, Cb min */
79
80	MDP_OUTP(MDP_BASE + 0xC000C, 0x67686970); /* add a few chars for CC */
81	MDP_OUTP(MDP_BASE + 0xC0000, 0x1); /* MDP tv out enable */
82
83	/* MDP cmd block disable */
84	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
85
86	ret = panel_next_on(pdev);
87
88	return ret;
89	}
90
91	int mdp_dma3_off(struct platform_device *pdev)
92	{
93	int ret = 0;
94
95	ret = panel_next_off(pdev);
96	if (ret)
97	return ret;
98
99	/* MDP cmd block enable */
100	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
101	MDP_OUTP(MDP_BASE + 0xC0000, 0x0);
102	/* MDP cmd block disable */
103	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
104
105	mdp_pipe_ctrl(MDP_DMA3_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
106
107	/* delay to make sure the last frame finishes */
108	mdelay(100);
109
110	return ret;
111	}
112
113	void mdp_dma3_update(struct msm_fb_data_type *mfd)
114	{
115	struct fb_info *fbi = mfd->fbi;
116	uint8 *buf;
117	int bpp;
118	unsigned long flag;
119
120	if (!mfd->panel_power_on)
121	return;
122
123	/* no need to power on cmd block since dma3 is running */
124	bpp = fbi->var.bits_per_pixel / 8;
125	buf = (uint8 *) fbi->fix.smem_start;
126	buf += fbi->var.xoffset * bpp +
127	fbi->var.yoffset * fbi->fix.line_length;
128	MDP_OUTP(MDP_BASE + 0xC0008, (uint32) buf >> 3);
129
130	spin_lock_irqsave(&mdp_spin_lock, flag);
131	mdp_enable_irq(MDP_DMA3_TERM);
132	INIT_COMPLETION(mfd->dma->comp);
133	mfd->dma->waiting = TRUE;
134
135	outp32(MDP_INTR_CLEAR, TV_OUT_DMA3_START);
136	mdp_intr_mask \|= TV_OUT_DMA3_START;
137	outp32(MDP_INTR_ENABLE, mdp_intr_mask);
138	spin_unlock_irqrestore(&mdp_spin_lock, flag);
139
140	wait_for_completion_killable(&mfd->dma->comp);
141	mdp_disable_irq(MDP_DMA3_TERM);
142	}