/* Copyright (c) 2009-2012, The Linux Foundation. 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.
 *
 */
#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 <linux/io.h>
#include <linux/debugfs.h>
#include <linux/semaphore.h>
#include <linux/uaccess.h>
#include <asm/system.h>
#include <asm/mach-types.h>
#include <mach/hardware.h>

#include "mdp.h"
#include "msm_fb.h"
#ifdef CONFIG_FB_MSM_MDP40
#include "mdp4.h"
#endif
#include "mddihosti.h"
#include "tvenc.h"
#ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL
#include "hdmi_msm.h"
#endif

#define MDP_DEBUG_BUF	2048

static uint32	mdp_offset;
static uint32	mdp_count;

static char	debug_buf[MDP_DEBUG_BUF];

/*
 * MDP4
 *
 */

static int mdp_offset_open(struct inode *inode, struct file *file)
{
	/* non-seekable */
	file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
	return 0;
}

static int mdp_offset_release(struct inode *inode, struct file *file)
{
	return 0;
}

static ssize_t mdp_offset_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	uint32 off, cnt;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	sscanf(debug_buf, "%x %d", &off, &cnt);

	if (cnt <= 0)
		cnt = 1;

	mdp_offset = off;
	mdp_count = cnt;

	printk(KERN_INFO "%s: offset=%x cnt=%d\n", __func__,
				mdp_offset, mdp_count);

	return count;
}

static ssize_t mdp_offset_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int len = 0;


	if (*ppos)
		return 0;	/* the end */

	len = snprintf(debug_buf, sizeof(debug_buf), "0x%08x %d\n",
					mdp_offset, mdp_count);
	if (len < 0)
		return 0;

	if (copy_to_user(buff, debug_buf, len))
		return -EFAULT;

	*ppos += len;	/* increase offset */

	return len;
}

static const struct file_operations mdp_off_fops = {
	.open = mdp_offset_open,
	.release = mdp_offset_release,
	.read = mdp_offset_read,
	.write = mdp_offset_write,
};

static int mdp_reg_open(struct inode *inode, struct file *file)
{
	/* non-seekable */
	file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
	return 0;
}

static int mdp_reg_release(struct inode *inode, struct file *file)
{
	return 0;
}

static ssize_t mdp_reg_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	uint32 off, data;
	int cnt;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x %x", &off, &data);

	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
	outpdw(MDP_BASE + off, data);
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);

	printk(KERN_INFO "%s: addr=%x data=%x\n", __func__, off, data);

	return count;
}

static ssize_t mdp_reg_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int len = 0;
	uint32 data;
	int i, j, off, dlen, num;
	char *bp, *cp;
	int tot = 0;


	if (*ppos)
		return 0;	/* the end */

	j = 0;
	num = 0;
	bp = debug_buf;
	cp = MDP_BASE + mdp_offset;
	dlen = sizeof(debug_buf);
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
	while (j++ < 8) {
		len = snprintf(bp, dlen, "0x%08x: ", (int)cp);
		tot += len;
		bp += len;
		dlen -= len;
		off = 0;
		i = 0;
		while (i++ < 4) {
			data = inpdw(cp + off);
			len = snprintf(bp, dlen, "%08x ", data);
			tot += len;
			bp += len;
			dlen -= len;
			off += 4;
			num++;
			if (num >= mdp_count)
				break;
		}
		*bp++ = '\n';
		--dlen;
		tot++;
		cp += off;
		if (num >= mdp_count)
			break;
	}
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
	*bp = 0;
	tot++;

	if (copy_to_user(buff, debug_buf, tot))
		return -EFAULT;

	*ppos += tot;	/* increase offset */

	return tot;
}


static const struct file_operations mdp_reg_fops = {
	.open = mdp_reg_open,
	.release = mdp_reg_release,
	.read = mdp_reg_read,
	.write = mdp_reg_write,
};

#ifdef CONFIG_FB_MSM_MDP40
static int mdp_stat_open(struct inode *inode, struct file *file)
{
	/* non-seekable */
	file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
	return 0;
}

static int mdp_stat_release(struct inode *inode, struct file *file)
{
	return 0;
}

static ssize_t mdp_stat_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	unsigned long flag;

	if (count > sizeof(debug_buf))
		return -EFAULT;

	spin_lock_irqsave(&mdp_spin_lock, flag);
	memset((char *)&mdp4_stat, 0 , sizeof(mdp4_stat));	/* reset */
	spin_unlock_irqrestore(&mdp_spin_lock, flag);

	return count;
}

static ssize_t mdp_stat_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int len = 0;
	int tot = 0;
	int dlen;
	char *bp;


	if (*ppos)
		return 0;	/* the end */

	bp = debug_buf;
	dlen = sizeof(debug_buf);

	len = snprintf(bp, dlen, "\nmdp:\n");
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "int_total: %08lu\t",
					mdp4_stat.intr_tot);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "int_overlay0: %08lu\t",
					mdp4_stat.intr_overlay0);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "int_overlay1: %08lu\n",
					mdp4_stat.intr_overlay1);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "int_overlay1: %08lu\n",
					mdp4_stat.intr_overlay2);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "int_dmap: %08lu\t",
					mdp4_stat.intr_dma_p);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "int_dmas: %08lu\t",
					mdp4_stat.intr_dma_s);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "int_dmae:  %08lu\n",
					mdp4_stat.intr_dma_e);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "primary:   vsync: %08lu\t",
					mdp4_stat.intr_vsync_p);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "underrun: %08lu\n",
					mdp4_stat.intr_underrun_p);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "external:  vsync: %08lu\t",
					mdp4_stat.intr_vsync_e);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "underrun: %08lu\n",
					mdp4_stat.intr_underrun_e);

	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "histogram: %08lu\t",
					mdp4_stat.intr_histogram);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "read_ptr: %08lu\n\n",
					mdp4_stat.intr_rdptr);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "dsi:\n");
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "int_total: %08lu\tmdp_start: %08lu\n",
			mdp4_stat.intr_dsi, mdp4_stat.dsi_mdp_start);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "int_cmd: %08lu\t",
					mdp4_stat.intr_dsi_cmd);

	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "int_mdp: %08lu\t",
					mdp4_stat.intr_dsi_mdp);

	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "int_err: %08lu\n",
					mdp4_stat.intr_dsi_err);

	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "clk_on : %08lu\t",
					mdp4_stat.dsi_clk_on);

	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "clk_off: %08lu\n\n",
					mdp4_stat.dsi_clk_off);

	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "kickoff:\n");
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "overlay0: %08lu\t",
					mdp4_stat.kickoff_ov0);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "dmap: %08lu\t",
					mdp4_stat.kickoff_dmap);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "dmas: %08lu\n",
					mdp4_stat.kickoff_dmas);

	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "overlay1: %08lu\t",
					mdp4_stat.kickoff_ov1);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "dmae: %08lu\n\n",
					mdp4_stat.kickoff_dmae);

	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "overlay0_play:\n");
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "set:   %08lu\t",
					mdp4_stat.overlay_set[0]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "unset: %08lu\t",
					mdp4_stat.overlay_unset[0]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "play:  %08lu\t",
					mdp4_stat.overlay_play[0]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "commit:  %08lu\n",
					mdp4_stat.overlay_commit[0]);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "overlay1_play:\n");
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "set:   %08lu\t",
					mdp4_stat.overlay_set[1]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "unset: %08lu\t",
					mdp4_stat.overlay_unset[1]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "play:  %08lu\t",
					mdp4_stat.overlay_play[1]);

	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "commit:  %08lu\n\n",
					mdp4_stat.overlay_commit[1]);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "frame_push:\n");
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "vg1 :   %08lu\t", mdp4_stat.pipe[0]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "vg2 :   %08lu\t", mdp4_stat.pipe[1]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "vg3 :   %08lu\n", mdp4_stat.pipe[5]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "rgb1:   %08lu\t", mdp4_stat.pipe[2]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "rgb2:   %08lu\t", mdp4_stat.pipe[3]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "rgb3:   %08lu\n\n", mdp4_stat.pipe[4]);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "wait4vsync: ");
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "mixer0 : %08lu\t", mdp4_stat.wait4vsync0);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "mixer1: %08lu\n\n", mdp4_stat.wait4vsync1);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "iommu: ");
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "map : %08lu\t", mdp4_stat.iommu_map);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "unmap: %08lu\t", mdp4_stat.iommu_unmap);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "drop: %08lu\n\n", mdp4_stat.iommu_drop);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "err_mixer : %08lu\t", mdp4_stat.err_mixer);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "err_size  : %08lu\n", mdp4_stat.err_size);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "err_scale : %08lu\t", mdp4_stat.err_scale);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "err_format: %08lu\n", mdp4_stat.err_format);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "err_play  : %08lu\t", mdp4_stat.err_play);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "err_stage : %08lu\n", mdp4_stat.err_stage);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "err_underflow: %08lu\n\n",
		       mdp4_stat.err_underflow);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "writeback:\n");
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "dsi_cmd: %08lu\t",
					mdp4_stat.blt_dsi_cmd);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "dsi_video: %08lu\n",
					mdp4_stat.blt_dsi_video);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "lcdc: %08lu\t",
					mdp4_stat.blt_lcdc);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "dtv: %08lu\t",
					mdp4_stat.blt_dtv);
	bp += len;
	dlen -= len;

	len = snprintf(bp, dlen, "mddi: %08lu\n\n",
					mdp4_stat.blt_mddi);
	bp += len;
	dlen -= len;

	tot = (uint32)bp - (uint32)debug_buf;
	*bp = 0;
	tot++;

	if (tot < 0)
		return 0;
	if (copy_to_user(buff, debug_buf, tot))
		return -EFAULT;

	*ppos += tot;	/* increase offset */

	return tot;
}

static const struct file_operations mdp_stat_fops = {
	.open = mdp_stat_open,
	.release = mdp_stat_release,
	.read = mdp_stat_read,
	.write = mdp_stat_write,
};
#endif

/*
 * MDDI
 *
 */

struct mddi_reg {
	char *name;
	int off;
};

static struct mddi_reg mddi_regs_list[] = {
	{"MDDI_CMD", MDDI_CMD},	 	/* 0x0000 */
	{"MDDI_VERSION", MDDI_VERSION},  /* 0x0004 */
	{"MDDI_PRI_PTR", MDDI_PRI_PTR},  /* 0x0008 */
	{"MDDI_BPS",  MDDI_BPS}, 	/* 0x0010 */
	{"MDDI_SPM", MDDI_SPM}, 	/* 0x0014 */
	{"MDDI_INT", MDDI_INT}, 	/* 0x0018 */
	{"MDDI_INTEN", MDDI_INTEN},	/* 0x001c */
	{"MDDI_REV_PTR", MDDI_REV_PTR},	/* 0x0020 */
	{"MDDI_	REV_SIZE", MDDI_REV_SIZE},/* 0x0024 */
	{"MDDI_STAT", MDDI_STAT},	/* 0x0028 */
	{"MDDI_REV_RATE_DIV", MDDI_REV_RATE_DIV}, /* 0x002c */
	{"MDDI_REV_CRC_ERR", MDDI_REV_CRC_ERR}, /* 0x0030 */
	{"MDDI_TA1_LEN", MDDI_TA1_LEN}, /* 0x0034 */
	{"MDDI_TA2_LEN", MDDI_TA2_LEN}, /* 0x0038 */
	{"MDDI_TEST", MDDI_TEST}, 	/* 0x0040 */
	{"MDDI_REV_PKT_CNT", MDDI_REV_PKT_CNT}, /* 0x0044 */
	{"MDDI_DRIVE_HI", MDDI_DRIVE_HI},/* 0x0048 */
	{"MDDI_DRIVE_LO", MDDI_DRIVE_LO},	/* 0x004c */
	{"MDDI_DISP_WAKE", MDDI_DISP_WAKE},/* 0x0050 */
	{"MDDI_REV_ENCAP_SZ", MDDI_REV_ENCAP_SZ}, /* 0x0054 */
	{"MDDI_RTD_VAL", MDDI_RTD_VAL}, /* 0x0058 */
	{"MDDI_PAD_CTL", MDDI_PAD_CTL},	 /* 0x0068 */
	{"MDDI_DRIVER_START_CNT", MDDI_DRIVER_START_CNT}, /* 0x006c */
	{"MDDI_CORE_VER", MDDI_CORE_VER}, /* 0x008c */
	{"MDDI_FIFO_ALLOC", MDDI_FIFO_ALLOC}, /* 0x0090 */
	{"MDDI_PAD_IO_CTL", MDDI_PAD_IO_CTL}, /* 0x00a0 */
	{"MDDI_PAD_CAL", MDDI_PAD_CAL},  /* 0x00a4 */
	{0, 0}
};

static int mddi_reg_open(struct inode *inode, struct file *file)
{
	/* non-seekable */
	file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
	return 0;
}

static int mddi_reg_release(struct inode *inode, struct file *file)
{
	return 0;
}

static void mddi_reg_write(int ndx, uint32 off, uint32 data)
{
	char *base;

	if (ndx)
		base = (char *)msm_emdh_base;
	else
		base = (char *)msm_pmdh_base;

	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
	writel(data, base + off);
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);

	printk(KERN_INFO "%s: addr=%x data=%x\n",
			__func__, (int)(base+off), (int)data);
}

static int mddi_reg_read(int ndx)
{
	struct mddi_reg *reg;
	unsigned char *base;
	int data;
	char *bp;
	int len = 0;
	int tot = 0;
	int dlen;

	if (ndx)
		base = msm_emdh_base;
	else
		base = msm_pmdh_base;

	reg = mddi_regs_list;
	bp = debug_buf;
	dlen = sizeof(debug_buf);

	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
	while (reg->name) {
		data = readl((u32)base + reg->off);
		len = snprintf(bp, dlen, "%s:0x%08x\t\t= 0x%08x\n",
					reg->name, reg->off, data);
		tot += len;
		bp += len;
		dlen -= len;
		reg++;
	}
	mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
	*bp = 0;
	tot++;

	return tot;
}

static ssize_t pmdh_reg_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	uint32 off, data;
	int cnt;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x %x", &off, &data);

	mddi_reg_write(0, off, data);

	return count;
}

static ssize_t pmdh_reg_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int tot = 0;

	if (*ppos)
		return 0;	/* the end */

	tot = mddi_reg_read(0);	/* pmdh */

	if (tot < 0)
		return 0;
	if (copy_to_user(buff, debug_buf, tot))
		return -EFAULT;

	*ppos += tot;	/* increase offset */

	return tot;
}


static const struct file_operations pmdh_fops = {
	.open = mddi_reg_open,
	.release = mddi_reg_release,
	.read = pmdh_reg_read,
	.write = pmdh_reg_write,
};

static ssize_t emdh_reg_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	uint32 off, data;
	int cnt;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x %x", &off, &data);

	mddi_reg_write(1, off, data);

	return count;
}

static ssize_t emdh_reg_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int tot = 0;

	if (*ppos)
		return 0;	/* the end */

	tot = mddi_reg_read(1);	/* emdh */

	if (tot < 0)
		return 0;
	if (copy_to_user(buff, debug_buf, tot))
		return -EFAULT;

	*ppos += tot;	/* increase offset */

	return tot;
}

static const struct file_operations emdh_fops = {
	.open = mddi_reg_open,
	.release = mddi_reg_release,
	.read = emdh_reg_read,
	.write = emdh_reg_write,
};


uint32 dbg_offset;
uint32 dbg_count;
char *dbg_base;


static int dbg_open(struct inode *inode, struct file *file)
{
	/* non-seekable */
	file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
	return 0;
}

static int dbg_release(struct inode *inode, struct file *file)
{
	return 0;
}

static ssize_t dbg_base_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	return count;
}

static ssize_t dbg_base_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int len = 0;
	int tot = 0;
	int dlen;
	char *bp;


	if (*ppos)
		return 0;	/* the end */


	bp = debug_buf;
	dlen = sizeof(debug_buf);

	len = snprintf(bp, dlen, "mdp_base  :    %08x\n",
				(int)msm_mdp_base);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "mddi_base :    %08x\n",
				(int)msm_pmdh_base);
	bp += len;
	dlen -= len;
	len = snprintf(bp, dlen, "emdh_base :    %08x\n",
				(int)msm_emdh_base);
	bp += len;
	dlen -= len;
#ifdef CONFIG_FB_MSM_TVOUT
	len = snprintf(bp, dlen, "tvenv_base:    %08x\n",
				(int)tvenc_base);
	bp += len;
	dlen -= len;
#endif

#ifdef CONFIG_FB_MSM_MIPI_DSI
	len = snprintf(bp, dlen, "mipi_dsi_base: %08x\n",
				(int)mipi_dsi_base);
	bp += len;
	dlen -= len;
#endif

	tot = (uint32)bp - (uint32)debug_buf;
	*bp = 0;
	tot++;

	if (tot < 0)
		return 0;
	if (copy_to_user(buff, debug_buf, tot))
		return -EFAULT;

	*ppos += tot;	/* increase offset */

	return tot;
}

static const struct file_operations dbg_base_fops = {
	.open = dbg_open,
	.release = dbg_release,
	.read = dbg_base_read,
	.write = dbg_base_write,
};

static ssize_t dbg_offset_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	uint32 off, cnt, num, base;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x %d %x", &off, &num, &base);

	if (cnt < 0)
		cnt = 0;

	if (cnt >= 1)
		dbg_offset = off;
	if (cnt >= 2)
		dbg_count = num;
	if (cnt >= 3)
		dbg_base = (char *)base;

	printk(KERN_INFO "%s: offset=%x cnt=%d base=%x\n", __func__,
				dbg_offset, dbg_count, (int)dbg_base);

	return count;
}

static ssize_t dbg_offset_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int len = 0;


	if (*ppos)
		return 0;	/* the end */

	len = snprintf(debug_buf, sizeof(debug_buf), "0x%08x %d 0x%08x\n",
				dbg_offset, dbg_count, (int)dbg_base);
	if (len < 0)
		return 0;

	if (copy_to_user(buff, debug_buf, len))
		return -EFAULT;

	*ppos += len;	/* increase offset */

	return len;
}

static const struct file_operations dbg_off_fops = {
	.open = dbg_open,
	.release = dbg_release,
	.read = dbg_offset_read,
	.write = dbg_offset_write,
};


static ssize_t dbg_reg_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	uint32 off, data;
	int cnt;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x %x", &off, &data);

	writel(data, dbg_base + off);

	printk(KERN_INFO "%s: addr=%x data=%x\n",
			__func__, (int)(dbg_base+off), (int)data);

	return count;
}

static ssize_t dbg_reg_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int len = 0;
	uint32 data;
	int i, j, off, dlen, num;
	char *bp, *cp;
	int tot = 0;


	if (*ppos)
		return 0;	/* the end */

	if (dbg_base == 0)
		return 0;	/* nothing to read */

	j = 0;
	num = 0;
	bp = debug_buf;
	cp = (char *)(dbg_base + dbg_offset);
	dlen = sizeof(debug_buf);
	while (j++ < 16) {
		len = snprintf(bp, dlen, "0x%08x: ", (int)cp);
		tot += len;
		bp += len;
		dlen -= len;
		off = 0;
		i = 0;
		while (i++ < 4) {
			data = readl(cp + off);
			len = snprintf(bp, dlen, "%08x ", data);
			tot += len;
			bp += len;
			dlen -= len;
			off += 4;
			num++;
			if (num >= dbg_count)
				break;
		}
		data = readl((u32)cp + off);
		*bp++ = '\n';
		--dlen;
		tot++;
		cp += off;
		if (num >= dbg_count)
			break;
	}
	*bp = 0;
	tot++;

	if (copy_to_user(buff, debug_buf, tot))
		return -EFAULT;

	*ppos += tot;	/* increase offset */

	return tot;
}


static const struct file_operations dbg_reg_fops = {
	.open = dbg_open,
	.release = dbg_release,
	.read = dbg_reg_read,
	.write = dbg_reg_write,
};

u32 dbg_force_ov0_blt;
u32 dbg_force_ov1_blt;

static ssize_t dbg_force_ov0_blt_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos) {
	int len;

	if (*ppos)
		return 0;

	len = snprintf(debug_buf, sizeof(debug_buf),
		       "%d\n", dbg_force_ov0_blt);

	if (len < 0)
		return 0;

	if (copy_to_user(buff, debug_buf, len))
		return -EFAULT;

	*ppos += len;

	return len;
}

static ssize_t dbg_force_ov0_blt_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	u32 cnt;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x", &dbg_force_ov0_blt);

	pr_info("%s: dbg_force_ov0_blt = %x\n",
		__func__, dbg_force_ov0_blt);

	if ((dbg_force_ov0_blt & 0x0f) > 2)
		pr_err("%s: invalid dbg_force_ov0_blt = %d\n",
			__func__, dbg_force_ov0_blt);

	if ((dbg_force_ov0_blt >> 4) > 2)
		pr_err("%s: invalid dbg_force_ov0_blt = %d\n",
			__func__, dbg_force_ov0_blt);

	return count;
}

static const struct file_operations dbg_force_ov0_blt_fops = {
	.open = dbg_open,
	.release = dbg_release,
	.read = dbg_force_ov0_blt_read,
	.write = dbg_force_ov0_blt_write,
};

static ssize_t dbg_force_ov1_blt_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos) {
	int len;

	if (*ppos)
		return 0;

	len = snprintf(debug_buf, sizeof(debug_buf),
		       "%x\n", dbg_force_ov1_blt);

	if (len < 0)
		return 0;

	if (copy_to_user(buff, debug_buf, len))
		return -EFAULT;

	*ppos += len;

	return len;
}

static ssize_t dbg_force_ov1_blt_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	u32 cnt;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x", &dbg_force_ov1_blt);

	pr_info("%s: dbg_force_ov1_blt = %x\n",
		__func__, dbg_force_ov1_blt);

	if ((dbg_force_ov1_blt & 0x0f) > 2)
		pr_err("%s: invalid dbg_force_ov1_blt = %x\n",
			__func__, dbg_force_ov1_blt);

	if ((dbg_force_ov1_blt >> 4) > 2)
		pr_err("%s: invalid dbg_force_ov1_blt = %d\n",
			__func__, dbg_force_ov1_blt);

	return count;
}

static const struct file_operations dbg_force_ov1_blt_fops = {
	.open = dbg_open,
	.release = dbg_release,
	.read = dbg_force_ov1_blt_read,
	.write = dbg_force_ov1_blt_write,
};

#ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL
static uint32 hdmi_offset;
static uint32 hdmi_count;

static int hdmi_open(struct inode *inode, struct file *file)
{
	/* non-seekable */
	file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
	return 0;
}

static int hdmi_release(struct inode *inode, struct file *file)
{
	return 0;
}

static ssize_t hdmi_offset_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	uint32 off, cnt, num;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x %d", &off, &num);

	if (cnt < 0)
		cnt = 0;

	if (cnt >= 1)
		hdmi_offset = off;
	if (cnt >= 2)
		hdmi_count = num;

	printk(KERN_INFO "%s: offset=%x cnt=%d\n", __func__,
				hdmi_offset, hdmi_count);

	return count;
}

static ssize_t hdmi_offset_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int len = 0;


	if (*ppos)
		return 0;	/* the end */

	len = snprintf(debug_buf, sizeof(debug_buf), "0x%08x %d\n",
				hdmi_offset, hdmi_count);
	if (len < 0)
		return 0;

	if (copy_to_user(buff, debug_buf, len))
		return -EFAULT;

	*ppos += len;	/* increase offset */

	return len;
}

static const struct file_operations hdmi_off_fops = {
	.open = hdmi_open,
	.release = hdmi_release,
	.read = hdmi_offset_read,
	.write = hdmi_offset_write,
};


static ssize_t hdmi_reg_write(
	struct file *file,
	const char __user *buff,
	size_t count,
	loff_t *ppos)
{
	uint32 off, data, base;
	int cnt;

	if (count >= sizeof(debug_buf))
		return -EFAULT;

	if (copy_from_user(debug_buf, buff, count))
		return -EFAULT;

	base = hdmi_msm_get_io_base();
	if (base == 0)
		return -EFAULT;

	debug_buf[count] = 0;	/* end of string */

	cnt = sscanf(debug_buf, "%x %x", &off, &data);

	writel(data, base + off);

	printk(KERN_INFO "%s: addr=%x data=%x\n",
			__func__, (int)(base+off), (int)data);

	return count;
}

static ssize_t hdmi_reg_read(
	struct file *file,
	char __user *buff,
	size_t count,
	loff_t *ppos)
{
	int len = 0;
	uint32 data;
	int i, j, off, dlen, num;
	char *bp, *cp;
	int tot = 0;


	if (*ppos)
		return 0;	/* the end */

	if (hdmi_msm_get_io_base() == 0)
		return 0;	/* nothing to read */

	j = 0;
	num = 0;
	bp = debug_buf;
	cp = (char *)(hdmi_msm_get_io_base() + hdmi_offset);
	dlen = sizeof(debug_buf);
	while (j++ < 16) {
		len = snprintf(bp, dlen, "0x%08x: ", (int)cp);
		tot += len;
		bp += len;
		dlen -= len;
		off = 0;
		i = 0;
		while (i++ < 4) {
			data = readl(cp + off);
			len = snprintf(bp, dlen, "%08x ", data);
			tot += len;
			bp += len;
			dlen -= len;
			off += 4;
			num++;
			if (num >= hdmi_count)
				break;
		}
		data = readl((u32)cp + off);
		*bp++ = '\n';
		--dlen;
		tot++;
		cp += off;
		if (num >= hdmi_count)
			break;
	}
	*bp = 0;
	tot++;

	if (copy_to_user(buff, debug_buf, tot))
		return -EFAULT;

	*ppos += tot;	/* increase offset */

	return tot;
}


static const struct file_operations hdmi_reg_fops = {
	.open = hdmi_open,
	.release = hdmi_release,
	.read = hdmi_reg_read,
	.write = hdmi_reg_write,
};
#endif

/*
 * debugfs
 *
 */

int mdp_debugfs_init(void)
{
	struct dentry *dent = debugfs_create_dir("mdp", NULL);

	if (IS_ERR(dent)) {
		printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n",
			__FILE__, __LINE__, PTR_ERR(dent));
		return -1;
	}

	if (debugfs_create_file("off", 0644, dent, 0, &mdp_off_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n",
			__FILE__, __LINE__);
		return -1;
	}

	if (debugfs_create_file("reg", 0644, dent, 0, &mdp_reg_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n",
			__FILE__, __LINE__);
		return -1;
	}

#ifdef CONFIG_FB_MSM_MDP40
	if (debugfs_create_file("stat", 0644, dent, 0, &mdp_stat_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n",
			__FILE__, __LINE__);
		return -1;
	}
#endif

	if (debugfs_create_file("force_ov0_blt", 0644, dent, 0,
				&dbg_force_ov0_blt_fops)
			== NULL) {
		pr_err("%s(%d): debugfs_create_file: debug fail\n",
			__FILE__, __LINE__);
		return -EFAULT;
	}

	if (debugfs_create_file("force_ov1_blt", 0644, dent, 0,
				&dbg_force_ov1_blt_fops)
			== NULL) {
		pr_err("%s(%d): debugfs_create_file: debug fail\n",
			__FILE__, __LINE__);
		return -EFAULT;
	}

	dent = debugfs_create_dir("mddi", NULL);

	if (IS_ERR(dent)) {
		printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n",
			__FILE__, __LINE__, PTR_ERR(dent));
		return -1;
	}

	if (debugfs_create_file("reg", 0644, dent, 0, &pmdh_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n",
			__FILE__, __LINE__);
		return -1;
	}

	dent = debugfs_create_dir("emdh", NULL);

	if (IS_ERR(dent)) {
		printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n",
			__FILE__, __LINE__, PTR_ERR(dent));
		return -1;
	}

	if (debugfs_create_file("reg", 0644, dent, 0, &emdh_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n",
			__FILE__, __LINE__);
		return -1;
	}

	dent = debugfs_create_dir("mdp-dbg", NULL);

	if (IS_ERR(dent)) {
		printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n",
			__FILE__, __LINE__, PTR_ERR(dent));
		return -1;
	}

	if (debugfs_create_file("base", 0644, dent, 0, &dbg_base_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n",
			__FILE__, __LINE__);
		return -1;
	}

	if (debugfs_create_file("off", 0644, dent, 0, &dbg_off_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n",
			__FILE__, __LINE__);
		return -1;
	}

	if (debugfs_create_file("reg", 0644, dent, 0, &dbg_reg_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n",
			__FILE__, __LINE__);
		return -1;
	}

#ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL
	dent = debugfs_create_dir("hdmi", NULL);

	if (IS_ERR(dent)) {
		printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n",
			__FILE__, __LINE__, PTR_ERR(dent));
		return PTR_ERR(dent);
	}

	if (debugfs_create_file("off", 0644, dent, 0, &hdmi_off_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: 'off' fail\n",
			__FILE__, __LINE__);
		return -ENOENT;
	}

	if (debugfs_create_file("reg", 0644, dent, 0, &hdmi_reg_fops)
			== NULL) {
		printk(KERN_ERR "%s(%d): debugfs_create_file: 'reg' fail\n",
			__FILE__, __LINE__);
		return -ENOENT;
	}
#endif

	return 0;
}