/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * 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/delay.h>
#include <linux/mutex.h>
#include <linux/pm_runtime.h>
#include <linux/regulator/consumer.h>
#include <linux/semaphore.h>
#include <linux/uaccess.h>
#include <asm/system.h>
#include <asm/mach-types.h>
#include <mach/clk.h>
#include <mach/hardware.h>
#include "msm_fb.h"

struct mdp_ccs mdp_ccs_rgb2yuv;
struct mdp_ccs mdp_ccs_yuv2rgb;

static struct platform_device *pdev_list[MSM_FB_MAX_DEV_LIST];
static int pdev_list_cnt;
static int ebi2_host_resource_initialized;
static struct msm_panel_common_pdata *ebi2_host_pdata;

static int ebi2_host_probe(struct platform_device *pdev);
static int ebi2_host_remove(struct platform_device *pdev);

static int ebi2_host_runtime_suspend(struct device *dev)
{
	dev_dbg(dev, "pm_runtime: suspending...\n");
	return 0;
}

static int ebi2_host_runtime_resume(struct device *dev)
{
	dev_dbg(dev, "pm_runtime: resuming...\n");
	return 0;
}

static const struct dev_pm_ops ebi2_host_dev_pm_ops = {
	.runtime_suspend = ebi2_host_runtime_suspend,
	.runtime_resume = ebi2_host_runtime_resume,
};


static struct platform_driver ebi2_host_driver = {
	.probe = ebi2_host_probe,
	.remove = ebi2_host_remove,
	.shutdown = NULL,
	.driver = {
		/*
		 * Simulate mdp hw
		 */
		.name = "mdp",
		.pm = &ebi2_host_dev_pm_ops,
	},
};

void mdp_pipe_ctrl(MDP_BLOCK_TYPE block, MDP_BLOCK_POWER_STATE state,
		   boolean isr)
{
	return;
}
int mdp_ppp_blit(struct fb_info *info, struct mdp_blit_req *req)
{
	return 0;
}
int mdp_start_histogram(struct fb_info *info)
{
	return 0;
}
int mdp_stop_histogram(struct fb_info *info)
{
	return 0;
}
void mdp_refresh_screen(unsigned long data)
{
	return;
}

static int ebi2_host_off(struct platform_device *pdev)
{
	int ret;
	ret = panel_next_off(pdev);
	return ret;
}

static int ebi2_host_on(struct platform_device *pdev)
{
	int ret;
	ret = panel_next_on(pdev);
	return ret;
}


static int ebi2_host_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;

	if ((pdev->id == 0) && (pdev->num_resources > 0)) {

		ebi2_host_pdata = pdev->dev.platform_data;

		ebi2_host_resource_initialized = 1;
		return 0;
	}

	ebi2_host_resource_initialized = 1;
	if (!ebi2_host_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;

	if (ebi2_host_pdata) {
		mfd->mdp_rev = ebi2_host_pdata->mdp_rev;
		mfd->mem_hid = ebi2_host_pdata->mem_hid;
	}

	/* add panel data */
	if (platform_device_add_data
	    (msm_fb_dev, pdev->dev.platform_data,
	     sizeof(struct msm_fb_panel_data))) {
		pr_err("ebi2_host_probe: platform_device_add_data failed!\n");
		rc = -ENOMEM;
		goto ebi2_host_probe_err;
	}
	/* data chain */
	pdata = msm_fb_dev->dev.platform_data;
	pdata->on = ebi2_host_on;
	pdata->off = ebi2_host_off;
	pdata->next = pdev;

	/* set driver data */
	platform_set_drvdata(msm_fb_dev, mfd);

	rc = platform_device_add(msm_fb_dev);
	if (rc)
		goto ebi2_host_probe_err;

	pm_runtime_set_active(&pdev->dev);
	pm_runtime_enable(&pdev->dev);

	pdev_list[pdev_list_cnt++] = pdev;
	return 0;

ebi2_host_probe_err:
	platform_device_put(msm_fb_dev);
	return rc;
}

void mdp_set_dma_pan_info(struct fb_info *info, struct mdp_dirty_region *dirty,
			  boolean sync)
{
	struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)info->par;
	struct fb_info *fbi = mfd->fbi;
	struct msm_panel_info *panel_info = &mfd->panel_info;
	MDPIBUF *iBuf;
	int bpp = info->var.bits_per_pixel / 8;
	int yres, remainder;

	if (panel_info->mode2_yres != 0) {
		yres = panel_info->mode2_yres;
		remainder = (fbi->fix.line_length*yres)%PAGE_SIZE;
	} else {
		yres = panel_info->yres;
		remainder = (fbi->fix.line_length*yres)%PAGE_SIZE;
	}

	if (!remainder)
		remainder = PAGE_SIZE;

	down(&mfd->sem);

	iBuf = &mfd->ibuf;
	/* use virtual address */
	iBuf->buf = (uint8 *) fbi->screen_base;

	if (fbi->var.yoffset < yres) {
		iBuf->buf += fbi->var.xoffset * bpp;
	} else if (fbi->var.yoffset >= yres && fbi->var.yoffset < 2 * yres) {
		iBuf->buf += fbi->var.xoffset * bpp + yres *
		fbi->fix.line_length + PAGE_SIZE - remainder;
	} else {
		iBuf->buf += fbi->var.xoffset * bpp + 2 * yres *
		fbi->fix.line_length + 2 * (PAGE_SIZE - remainder);
	}

	iBuf->ibuf_width = info->var.xres_virtual;
	iBuf->bpp = bpp;

	iBuf->vsync_enable = sync;

	if (dirty) {
		/*
		 * ToDo: dirty region check inside var.xoffset+xres
		 * <-> var.yoffset+yres
		 */
		iBuf->dma_x = dirty->xoffset % info->var.xres;
		iBuf->dma_y = dirty->yoffset % info->var.yres;
		iBuf->dma_w = dirty->width;
		iBuf->dma_h = dirty->height;
	} else {
		iBuf->dma_x = 0;
		iBuf->dma_y = 0;
		iBuf->dma_w = info->var.xres;
		iBuf->dma_h = info->var.yres;
	}
	mfd->ibuf_flushed = FALSE;
	up(&mfd->sem);
}

void mdp_dma_pan_update(struct fb_info *info)
{
	struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)info->par;
	MDPIBUF *iBuf;
	int i, j;
	uint32 data;
	uint8 *src;
	struct msm_fb_panel_data *pdata =
	    (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data;
	struct fb_info *fbi = mfd->fbi;

	iBuf = &mfd->ibuf;

	invalidate_caches((unsigned long)fbi->screen_base,
		(unsigned long)info->fix.smem_len,
		(unsigned long)info->fix.smem_start);

	pdata->set_rect(iBuf->dma_x, iBuf->dma_y, iBuf->dma_w,
			iBuf->dma_h);
	for (i = 0; i < iBuf->dma_h; i++) {
		src = iBuf->buf + (fbi->fix.line_length * (iBuf->dma_y + i))
			+ (iBuf->dma_x * iBuf->bpp);
		for (j = 0; j < iBuf->dma_w; j++) {
			data = (uint32)(*src++ >> 2) << 12;
			data |= (uint32)(*src++ >> 2) << 6;
			data |= (uint32)(*src++ >> 2);
			data = ((data&0x1FF)<<16) | ((data&0x3FE00)>>9);
			outpdw(mfd->data_port, data);
		}
	}
}

static int ebi2_host_remove(struct platform_device *pdev)
{
	pm_runtime_disable(&pdev->dev);

	return 0;
}

static int ebi2_host_register_driver(void)
{
	return platform_driver_register(&ebi2_host_driver);
}

static int __init ebi2_host_driver_init(void)
{
	int ret;

	ret = ebi2_host_register_driver();
	if (ret) {
		pr_err("ebi2_host_register_driver() failed!\n");
		return ret;
	}

	return 0;
}

module_init(ebi2_host_driver_init);