[linux-2.6-block.git] / drivers / video / fbdev / exynos / exynos_mipi_dsi.c

/* linux/drivers/video/exynos/exynos_mipi_dsi.c
 *
 * Samsung SoC MIPI-DSIM driver.
 *
 * Copyright (c) 2012 Samsung Electronics Co., Ltd
 *
 * InKi Dae, <inki.dae@samsung.com>
 * Donghwa Lee, <dh09.lee@samsung.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/clk.h>
#include <linux/mutex.h>
#include <linux/wait.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/fb.h>
#include <linux/ctype.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/memory.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/kthread.h>
#include <linux/notifier.h>
#include <linux/phy/phy.h>
#include <linux/regulator/consumer.h>
#include <linux/pm_runtime.h>
#include <linux/err.h>

#include <video/exynos_mipi_dsim.h>

#include "exynos_mipi_dsi_common.h"
#include "exynos_mipi_dsi_lowlevel.h"

struct mipi_dsim_ddi {
	int				bus_id;
	struct list_head		list;
	struct mipi_dsim_lcd_device	*dsim_lcd_dev;
	struct mipi_dsim_lcd_driver	*dsim_lcd_drv;
};

static LIST_HEAD(dsim_ddi_list);

static DEFINE_MUTEX(mipi_dsim_lock);

static struct mipi_dsim_platform_data *to_dsim_plat(struct platform_device
							*pdev)
{
	return pdev->dev.platform_data;
}

static struct regulator_bulk_data supplies[] = {
	{ .supply = "vdd11", },
	{ .supply = "vdd18", },
};

static int exynos_mipi_regulator_enable(struct mipi_dsim_device *dsim)
{
	int ret;

	mutex_lock(&dsim->lock);
	ret = regulator_bulk_enable(ARRAY_SIZE(supplies), supplies);
	mutex_unlock(&dsim->lock);

	return ret;
}

static int exynos_mipi_regulator_disable(struct mipi_dsim_device *dsim)
{
	int ret;

	mutex_lock(&dsim->lock);
	ret = regulator_bulk_disable(ARRAY_SIZE(supplies), supplies);
	mutex_unlock(&dsim->lock);

	return ret;
}

/* update all register settings to MIPI DSI controller. */
static void exynos_mipi_update_cfg(struct mipi_dsim_device *dsim)
{
	/*
	 * data from Display controller(FIMD) is not transferred in video mode
	 * but in case of command mode, all settings is not updated to
	 * registers.
	 */
	exynos_mipi_dsi_stand_by(dsim, 0);

	exynos_mipi_dsi_init_dsim(dsim);
	exynos_mipi_dsi_init_link(dsim);

	exynos_mipi_dsi_set_hs_enable(dsim);

	/* set display timing. */
	exynos_mipi_dsi_set_display_mode(dsim, dsim->dsim_config);

	exynos_mipi_dsi_init_interrupt(dsim);

	/*
	 * data from Display controller(FIMD) is transferred in video mode
	 * but in case of command mode, all settings are updated to registers.
	 */
	exynos_mipi_dsi_stand_by(dsim, 1);
}

static int exynos_mipi_dsi_early_blank_mode(struct mipi_dsim_device *dsim,
		int power)
{
	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;

	switch (power) {
	case FB_BLANK_POWERDOWN:
		if (dsim->suspended)
			return 0;

		if (client_drv && client_drv->suspend)
			client_drv->suspend(client_dev);

		clk_disable(dsim->clock);

		exynos_mipi_regulator_disable(dsim);

		dsim->suspended = true;

		break;
	default:
		break;
	}

	return 0;
}

static int exynos_mipi_dsi_blank_mode(struct mipi_dsim_device *dsim, int power)
{
	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;

	switch (power) {
	case FB_BLANK_UNBLANK:
		if (!dsim->suspended)
			return 0;

		/* lcd panel power on. */
		if (client_drv && client_drv->power_on)
			client_drv->power_on(client_dev, 1);

		exynos_mipi_regulator_enable(dsim);

		/* enable MIPI-DSI PHY. */
		phy_power_on(dsim->phy);

		clk_enable(dsim->clock);

		exynos_mipi_update_cfg(dsim);

		/* set lcd panel sequence commands. */
		if (client_drv && client_drv->set_sequence)
			client_drv->set_sequence(client_dev);

		dsim->suspended = false;

		break;
	case FB_BLANK_NORMAL:
		/* TODO. */
		break;
	default:
		break;
	}

	return 0;
}

int exynos_mipi_dsi_register_lcd_device(struct mipi_dsim_lcd_device *lcd_dev)
{
	struct mipi_dsim_ddi *dsim_ddi;

	if (!lcd_dev->name) {
		pr_err("dsim_lcd_device name is NULL.\n");
		return -EFAULT;
	}

	dsim_ddi = kzalloc(sizeof(struct mipi_dsim_ddi), GFP_KERNEL);
	if (!dsim_ddi) {
		pr_err("failed to allocate dsim_ddi object.\n");
		return -ENOMEM;
	}

	dsim_ddi->dsim_lcd_dev = lcd_dev;

	mutex_lock(&mipi_dsim_lock);
	list_add_tail(&dsim_ddi->list, &dsim_ddi_list);
	mutex_unlock(&mipi_dsim_lock);

	return 0;
}

static struct mipi_dsim_ddi *exynos_mipi_dsi_find_lcd_device(
					struct mipi_dsim_lcd_driver *lcd_drv)
{
	struct mipi_dsim_ddi *dsim_ddi, *next;
	struct mipi_dsim_lcd_device *lcd_dev;

	mutex_lock(&mipi_dsim_lock);

	list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
		if (!dsim_ddi)
			goto out;

		lcd_dev = dsim_ddi->dsim_lcd_dev;
		if (!lcd_dev)
			continue;

		if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0) {
			/**
			 * bus_id would be used to identify
			 * connected bus.
			 */
			dsim_ddi->bus_id = lcd_dev->bus_id;
			mutex_unlock(&mipi_dsim_lock);

			return dsim_ddi;
		}

		list_del(&dsim_ddi->list);
		kfree(dsim_ddi);
	}

out:
	mutex_unlock(&mipi_dsim_lock);

	return NULL;
}

int exynos_mipi_dsi_register_lcd_driver(struct mipi_dsim_lcd_driver *lcd_drv)
{
	struct mipi_dsim_ddi *dsim_ddi;

	if (!lcd_drv->name) {
		pr_err("dsim_lcd_driver name is NULL.\n");
		return -EFAULT;
	}

	dsim_ddi = exynos_mipi_dsi_find_lcd_device(lcd_drv);
	if (!dsim_ddi) {
		pr_err("mipi_dsim_ddi object not found.\n");
		return -EFAULT;
	}

	dsim_ddi->dsim_lcd_drv = lcd_drv;

	pr_info("registered panel driver(%s) to mipi-dsi driver.\n",
		lcd_drv->name);

	return 0;

}
EXPORT_SYMBOL_GPL(exynos_mipi_dsi_register_lcd_driver);

static struct mipi_dsim_ddi *exynos_mipi_dsi_bind_lcd_ddi(
						struct mipi_dsim_device *dsim,
						const char *name)
{
	struct mipi_dsim_ddi *dsim_ddi, *next;
	struct mipi_dsim_lcd_driver *lcd_drv;
	struct mipi_dsim_lcd_device *lcd_dev;
	int ret;

	mutex_lock(&dsim->lock);

	list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
		lcd_drv = dsim_ddi->dsim_lcd_drv;
		lcd_dev = dsim_ddi->dsim_lcd_dev;
		if (!lcd_drv || !lcd_dev ||
			(dsim->id != dsim_ddi->bus_id))
				continue;

		dev_dbg(dsim->dev, "lcd_drv->id = %d, lcd_dev->id = %d\n",
				lcd_drv->id, lcd_dev->id);
		dev_dbg(dsim->dev, "lcd_dev->bus_id = %d, dsim->id = %d\n",
				lcd_dev->bus_id, dsim->id);

		if ((strcmp(lcd_drv->name, name) == 0)) {
			lcd_dev->master = dsim;

			lcd_dev->dev.parent = dsim->dev;
			dev_set_name(&lcd_dev->dev, "%s", lcd_drv->name);

			ret = device_register(&lcd_dev->dev);
			if (ret < 0) {
				dev_err(dsim->dev,
					"can't register %s, status %d\n",
					dev_name(&lcd_dev->dev), ret);
				mutex_unlock(&dsim->lock);

				return NULL;
			}

			dsim->dsim_lcd_dev = lcd_dev;
			dsim->dsim_lcd_drv = lcd_drv;

			mutex_unlock(&dsim->lock);

			return dsim_ddi;
		}
	}

	mutex_unlock(&dsim->lock);

	return NULL;
}

/* define MIPI-DSI Master operations. */
static struct mipi_dsim_master_ops master_ops = {
	.cmd_read			= exynos_mipi_dsi_rd_data,
	.cmd_write			= exynos_mipi_dsi_wr_data,
	.get_dsim_frame_done		= exynos_mipi_dsi_get_frame_done_status,
	.clear_dsim_frame_done		= exynos_mipi_dsi_clear_frame_done,
	.set_early_blank_mode		= exynos_mipi_dsi_early_blank_mode,
	.set_blank_mode			= exynos_mipi_dsi_blank_mode,
};

static int exynos_mipi_dsi_probe(struct platform_device *pdev)
{
	struct resource *res;
	struct mipi_dsim_device *dsim;
	struct mipi_dsim_config *dsim_config;
	struct mipi_dsim_platform_data *dsim_pd;
	struct mipi_dsim_ddi *dsim_ddi;
	int ret = -EINVAL;

	dsim = devm_kzalloc(&pdev->dev, sizeof(struct mipi_dsim_device),
				GFP_KERNEL);
	if (!dsim) {
		dev_err(&pdev->dev, "failed to allocate dsim object.\n");
		return -ENOMEM;
	}

	dsim->pd = to_dsim_plat(pdev);
	dsim->dev = &pdev->dev;
	dsim->id = pdev->id;

	/* get mipi_dsim_platform_data. */
	dsim_pd = (struct mipi_dsim_platform_data *)dsim->pd;
	if (dsim_pd == NULL) {
		dev_err(&pdev->dev, "failed to get platform data for dsim.\n");
		return -EINVAL;
	}
	/* get mipi_dsim_config. */
	dsim_config = dsim_pd->dsim_config;
	if (dsim_config == NULL) {
		dev_err(&pdev->dev, "failed to get dsim config data.\n");
		return -EINVAL;
	}

	dsim->dsim_config = dsim_config;
	dsim->master_ops = &master_ops;

	mutex_init(&dsim->lock);

	ret = devm_regulator_bulk_get(&pdev->dev, ARRAY_SIZE(supplies),
					supplies);
	if (ret) {
		dev_err(&pdev->dev, "Failed to get regulators: %d\n", ret);
		return ret;
	}

	dsim->phy = devm_phy_get(&pdev->dev, "dsim");
	if (IS_ERR(dsim->phy))
		return PTR_ERR(dsim->phy);

	dsim->clock = devm_clk_get(&pdev->dev, "dsim0");
	if (IS_ERR(dsim->clock)) {
		dev_err(&pdev->dev, "failed to get dsim clock source\n");
		return -ENODEV;
	}

	clk_enable(dsim->clock);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	dsim->reg_base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(dsim->reg_base)) {
		ret = PTR_ERR(dsim->reg_base);
		goto error;
	}

	mutex_init(&dsim->lock);

	/* bind lcd ddi matched with panel name. */
	dsim_ddi = exynos_mipi_dsi_bind_lcd_ddi(dsim, dsim_pd->lcd_panel_name);
	if (!dsim_ddi) {
		dev_err(&pdev->dev, "mipi_dsim_ddi object not found.\n");
		ret = -EINVAL;
		goto error;
	}

	ret = platform_get_irq(pdev, 0);
	if (ret < 0) {
		dev_err(&pdev->dev, "failed to request dsim irq resource\n");
		goto error;
	}
	dsim->irq = ret;

	init_completion(&dsim_wr_comp);
	init_completion(&dsim_rd_comp);
	platform_set_drvdata(pdev, dsim);

	ret = devm_request_irq(&pdev->dev, dsim->irq,
			exynos_mipi_dsi_interrupt_handler,
			IRQF_SHARED, dev_name(&pdev->dev), dsim);
	if (ret != 0) {
		dev_err(&pdev->dev, "failed to request dsim irq\n");
		ret = -EINVAL;
		goto error;
	}

	/* enable interrupts */
	exynos_mipi_dsi_init_interrupt(dsim);

	/* initialize mipi-dsi client(lcd panel). */
	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->probe)
		dsim_ddi->dsim_lcd_drv->probe(dsim_ddi->dsim_lcd_dev);

	/* in case mipi-dsi has been enabled by bootloader */
	if (dsim_pd->enabled) {
		exynos_mipi_regulator_enable(dsim);
		goto done;
	}

	/* lcd panel power on. */
	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->power_on)
		dsim_ddi->dsim_lcd_drv->power_on(dsim_ddi->dsim_lcd_dev, 1);

	exynos_mipi_regulator_enable(dsim);

	/* enable MIPI-DSI PHY. */
	phy_power_on(dsim->phy);

	exynos_mipi_update_cfg(dsim);

	/* set lcd panel sequence commands. */
	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->set_sequence)
		dsim_ddi->dsim_lcd_drv->set_sequence(dsim_ddi->dsim_lcd_dev);

	dsim->suspended = false;

done:
	platform_set_drvdata(pdev, dsim);

	dev_dbg(&pdev->dev, "%s() completed successfully (%s mode)\n", __func__,
		dsim_config->e_interface == DSIM_COMMAND ? "CPU" : "RGB");

	return 0;

error:
	clk_disable(dsim->clock);
	return ret;
}

static int exynos_mipi_dsi_remove(struct platform_device *pdev)
{
	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	struct mipi_dsim_ddi *dsim_ddi, *next;
	struct mipi_dsim_lcd_driver *dsim_lcd_drv;

	clk_disable(dsim->clock);

	list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
		if (dsim_ddi) {
			if (dsim->id != dsim_ddi->bus_id)
				continue;

			dsim_lcd_drv = dsim_ddi->dsim_lcd_drv;

			if (dsim_lcd_drv->remove)
				dsim_lcd_drv->remove(dsim_ddi->dsim_lcd_dev);

			kfree(dsim_ddi);
		}
	}

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int exynos_mipi_dsi_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;

	disable_irq(dsim->irq);

	if (dsim->suspended)
		return 0;

	if (client_drv && client_drv->suspend)
		client_drv->suspend(client_dev);

	/* disable MIPI-DSI PHY. */
	phy_power_off(dsim->phy);

	clk_disable(dsim->clock);

	exynos_mipi_regulator_disable(dsim);

	dsim->suspended = true;

	return 0;
}

static int exynos_mipi_dsi_resume(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;

	enable_irq(dsim->irq);

	if (!dsim->suspended)
		return 0;

	/* lcd panel power on. */
	if (client_drv && client_drv->power_on)
		client_drv->power_on(client_dev, 1);

	exynos_mipi_regulator_enable(dsim);

	/* enable MIPI-DSI PHY. */
	phy_power_on(dsim->phy);

	clk_enable(dsim->clock);

	exynos_mipi_update_cfg(dsim);

	/* set lcd panel sequence commands. */
	if (client_drv && client_drv->set_sequence)
		client_drv->set_sequence(client_dev);

	dsim->suspended = false;

	return 0;
}
#endif

static const struct dev_pm_ops exynos_mipi_dsi_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(exynos_mipi_dsi_suspend, exynos_mipi_dsi_resume)
};

static struct platform_driver exynos_mipi_dsi_driver = {
	.probe = exynos_mipi_dsi_probe,
	.remove = exynos_mipi_dsi_remove,
	.driver = {
		   .name = "exynos-mipi-dsim",
		   .pm = &exynos_mipi_dsi_pm_ops,
	},
};

module_platform_driver(exynos_mipi_dsi_driver);

MODULE_AUTHOR("InKi Dae <inki.dae@samsung.com>");
MODULE_DESCRIPTION("Samsung SoC MIPI-DSI driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
7258cc14 DL	1	/* linux/drivers/video/exynos/exynos_mipi_dsi.c
	2	*
	3	* Samsung SoC MIPI-DSIM driver.
	4	*
	5	* Copyright (c) 2012 Samsung Electronics Co., Ltd
	6	*
	7	* InKi Dae, <inki.dae@samsung.com>
	8	* Donghwa Lee, <dh09.lee@samsung.com>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
	14
	15	#include <linux/module.h>
	16	#include <linux/kernel.h>
	17	#include <linux/errno.h>
	18	#include <linux/clk.h>
	19	#include <linux/mutex.h>
	20	#include <linux/wait.h>
	21	#include <linux/fs.h>
	22	#include <linux/mm.h>
	23	#include <linux/fb.h>
	24	#include <linux/ctype.h>
	25	#include <linux/platform_device.h>
	26	#include <linux/io.h>
	27	#include <linux/irq.h>
	28	#include <linux/memory.h>
	29	#include <linux/delay.h>
	30	#include <linux/interrupt.h>
	31	#include <linux/kthread.h>
	32	#include <linux/notifier.h>
7e0be9f9	33	#include <linux/phy/phy.h>
7258cc14 DL	34	#include <linux/regulator/consumer.h>
7258cc14 DL	35	#include <linux/pm_runtime.h>
6637eca3	36	#include <linux/err.h>
7258cc14 DL	37
	38	#include <video/exynos_mipi_dsim.h>
	39
7258cc14 DL	40	#include "exynos_mipi_dsi_common.h"
	41	#include "exynos_mipi_dsi_lowlevel.h"
	42
	43	struct mipi_dsim_ddi {
	44	int bus_id;
	45	struct list_head list;
	46	struct mipi_dsim_lcd_device *dsim_lcd_dev;
	47	struct mipi_dsim_lcd_driver *dsim_lcd_drv;
	48	};
	49
	50	static LIST_HEAD(dsim_ddi_list);
	51
	52	static DEFINE_MUTEX(mipi_dsim_lock);
	53
	54	static struct mipi_dsim_platform_data *to_dsim_plat(struct platform_device
	55	*pdev)
	56	{
	57	return pdev->dev.platform_data;
	58	}
	59
	60	static struct regulator_bulk_data supplies[] = {
66685aa0	61	{ .supply = "vdd11", },
7258cc14 DL	62	{ .supply = "vdd18", },
	63	};
	64
	65	static int exynos_mipi_regulator_enable(struct mipi_dsim_device *dsim)
	66	{
	67	int ret;
	68
	69	mutex_lock(&dsim->lock);
	70	ret = regulator_bulk_enable(ARRAY_SIZE(supplies), supplies);
	71	mutex_unlock(&dsim->lock);
	72
	73	return ret;
	74	}
	75
	76	static int exynos_mipi_regulator_disable(struct mipi_dsim_device *dsim)
	77	{
	78	int ret;
	79
	80	mutex_lock(&dsim->lock);
	81	ret = regulator_bulk_disable(ARRAY_SIZE(supplies), supplies);
	82	mutex_unlock(&dsim->lock);
	83
	84	return ret;
	85	}
	86
	87	/* update all register settings to MIPI DSI controller. */
	88	static void exynos_mipi_update_cfg(struct mipi_dsim_device *dsim)
	89	{
	90	/*
	91	* data from Display controller(FIMD) is not transferred in video mode
	92	* but in case of command mode, all settings is not updated to
	93	* registers.
	94	*/
	95	exynos_mipi_dsi_stand_by(dsim, 0);
	96
	97	exynos_mipi_dsi_init_dsim(dsim);
	98	exynos_mipi_dsi_init_link(dsim);
	99
	100	exynos_mipi_dsi_set_hs_enable(dsim);
	101
	102	/* set display timing. */
	103	exynos_mipi_dsi_set_display_mode(dsim, dsim->dsim_config);
	104
113b6684 DL	105	exynos_mipi_dsi_init_interrupt(dsim);
113b6684 DL	106
7258cc14 DL	107	/*
7258cc14 DL	108	* data from Display controller(FIMD) is transferred in video mode
ff0c2642	109	* but in case of command mode, all settings are updated to registers.
7258cc14 DL	110	*/
	111	exynos_mipi_dsi_stand_by(dsim, 1);
	112	}
	113
	114	static int exynos_mipi_dsi_early_blank_mode(struct mipi_dsim_device *dsim,
	115	int power)
	116	{
	117	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	118	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
	119
	120	switch (power) {
	121	case FB_BLANK_POWERDOWN:
	122	if (dsim->suspended)
	123	return 0;
	124
	125	if (client_drv && client_drv->suspend)
	126	client_drv->suspend(client_dev);
	127
	128	clk_disable(dsim->clock);
	129
	130	exynos_mipi_regulator_disable(dsim);
	131
	132	dsim->suspended = true;
	133
	134	break;
	135	default:
	136	break;
	137	}
	138
	139	return 0;
	140	}
	141
	142	static int exynos_mipi_dsi_blank_mode(struct mipi_dsim_device *dsim, int power)
	143	{
7258cc14 DL	144	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	145	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
	146
	147	switch (power) {
	148	case FB_BLANK_UNBLANK:
	149	if (!dsim->suspended)
	150	return 0;
	151
	152	/* lcd panel power on. */
	153	if (client_drv && client_drv->power_on)
	154	client_drv->power_on(client_dev, 1);
	155
91d1cfa8	156	exynos_mipi_regulator_enable(dsim);
7258cc14 DL	157
7258cc14 DL	158	/* enable MIPI-DSI PHY. */
7e0be9f9	159	phy_power_on(dsim->phy);
7258cc14 DL	160
	161	clk_enable(dsim->clock);
	162
	163	exynos_mipi_update_cfg(dsim);
	164
	165	/* set lcd panel sequence commands. */
	166	if (client_drv && client_drv->set_sequence)
	167	client_drv->set_sequence(client_dev);
	168
	169	dsim->suspended = false;
	170
	171	break;
	172	case FB_BLANK_NORMAL:
	173	/* TODO. */
	174	break;
	175	default:
	176	break;
	177	}
	178
	179	return 0;
	180	}
	181
	182	int exynos_mipi_dsi_register_lcd_device(struct mipi_dsim_lcd_device *lcd_dev)
	183	{
	184	struct mipi_dsim_ddi *dsim_ddi;
	185
	186	if (!lcd_dev->name) {
	187	pr_err("dsim_lcd_device name is NULL.\n");
	188	return -EFAULT;
	189	}
	190
	191	dsim_ddi = kzalloc(sizeof(struct mipi_dsim_ddi), GFP_KERNEL);
	192	if (!dsim_ddi) {
	193	pr_err("failed to allocate dsim_ddi object.\n");
	194	return -ENOMEM;
	195	}
	196
	197	dsim_ddi->dsim_lcd_dev = lcd_dev;
	198
	199	mutex_lock(&mipi_dsim_lock);
	200	list_add_tail(&dsim_ddi->list, &dsim_ddi_list);
	201	mutex_unlock(&mipi_dsim_lock);
	202
	203	return 0;
	204	}
	205
4c4ceee0 SK	206	static struct mipi_dsim_ddi *exynos_mipi_dsi_find_lcd_device(
4c4ceee0 SK	207	struct mipi_dsim_lcd_driver *lcd_drv)
7258cc14 DL	208	{
	209	struct mipi_dsim_ddi dsim_ddi, next;
	210	struct mipi_dsim_lcd_device *lcd_dev;
	211
	212	mutex_lock(&mipi_dsim_lock);
	213
	214	list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
	215	if (!dsim_ddi)
	216	goto out;
	217
	218	lcd_dev = dsim_ddi->dsim_lcd_dev;
	219	if (!lcd_dev)
	220	continue;
	221
	222	if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0) {
	223	/**
	224	* bus_id would be used to identify
	225	* connected bus.
	226	*/
	227	dsim_ddi->bus_id = lcd_dev->bus_id;
	228	mutex_unlock(&mipi_dsim_lock);
	229
	230	return dsim_ddi;
	231	}
	232
	233	list_del(&dsim_ddi->list);
	234	kfree(dsim_ddi);
	235	}
	236
	237	out:
	238	mutex_unlock(&mipi_dsim_lock);
	239
	240	return NULL;
	241	}
	242
	243	int exynos_mipi_dsi_register_lcd_driver(struct mipi_dsim_lcd_driver *lcd_drv)
	244	{
	245	struct mipi_dsim_ddi *dsim_ddi;
	246
	247	if (!lcd_drv->name) {
	248	pr_err("dsim_lcd_driver name is NULL.\n");
	249	return -EFAULT;
	250	}
	251
	252	dsim_ddi = exynos_mipi_dsi_find_lcd_device(lcd_drv);
	253	if (!dsim_ddi) {
	254	pr_err("mipi_dsim_ddi object not found.\n");
	255	return -EFAULT;
	256	}
	257
	258	dsim_ddi->dsim_lcd_drv = lcd_drv;
	259
	260	pr_info("registered panel driver(%s) to mipi-dsi driver.\n",
	261	lcd_drv->name);
	262
	263	return 0;
	264
	265	}
5a63ddf6	266	EXPORT_SYMBOL_GPL(exynos_mipi_dsi_register_lcd_driver);
7258cc14	267
4c4ceee0 SK	268	static struct mipi_dsim_ddi *exynos_mipi_dsi_bind_lcd_ddi(
4c4ceee0 SK	269	struct mipi_dsim_device *dsim,
7258cc14 DL	270	const char *name)
	271	{
	272	struct mipi_dsim_ddi dsim_ddi, next;
	273	struct mipi_dsim_lcd_driver *lcd_drv;
	274	struct mipi_dsim_lcd_device *lcd_dev;
	275	int ret;
	276
	277	mutex_lock(&dsim->lock);
	278
	279	list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
	280	lcd_drv = dsim_ddi->dsim_lcd_drv;
	281	lcd_dev = dsim_ddi->dsim_lcd_dev;
	282	if (!lcd_drv \|\| !lcd_dev \|\|
	283	(dsim->id != dsim_ddi->bus_id))
	284	continue;
	285
	286	dev_dbg(dsim->dev, "lcd_drv->id = %d, lcd_dev->id = %d\n",
	287	lcd_drv->id, lcd_dev->id);
	288	dev_dbg(dsim->dev, "lcd_dev->bus_id = %d, dsim->id = %d\n",
	289	lcd_dev->bus_id, dsim->id);
	290
	291	if ((strcmp(lcd_drv->name, name) == 0)) {
	292	lcd_dev->master = dsim;
	293
	294	lcd_dev->dev.parent = dsim->dev;
	295	dev_set_name(&lcd_dev->dev, "%s", lcd_drv->name);
	296
	297	ret = device_register(&lcd_dev->dev);
	298	if (ret < 0) {
	299	dev_err(dsim->dev,
	300	"can't register %s, status %d\n",
	301	dev_name(&lcd_dev->dev), ret);
	302	mutex_unlock(&dsim->lock);
	303
	304	return NULL;
	305	}
	306
	307	dsim->dsim_lcd_dev = lcd_dev;
	308	dsim->dsim_lcd_drv = lcd_drv;
	309
	310	mutex_unlock(&dsim->lock);
	311
	312	return dsim_ddi;
	313	}
	314	}
	315
	316	mutex_unlock(&dsim->lock);
	317
	318	return NULL;
	319	}
	320
	321	/* define MIPI-DSI Master operations. */
	322	static struct mipi_dsim_master_ops master_ops = {
	323	.cmd_read = exynos_mipi_dsi_rd_data,
	324	.cmd_write = exynos_mipi_dsi_wr_data,
	325	.get_dsim_frame_done = exynos_mipi_dsi_get_frame_done_status,
	326	.clear_dsim_frame_done = exynos_mipi_dsi_clear_frame_done,
	327	.set_early_blank_mode = exynos_mipi_dsi_early_blank_mode,
	328	.set_blank_mode = exynos_mipi_dsi_blank_mode,
	329	};
	330
	331	static int exynos_mipi_dsi_probe(struct platform_device *pdev)
	332	{
	333	struct resource *res;
334	struct mipi_dsim_device *dsim;
335	struct mipi_dsim_config *dsim_config;
336	struct mipi_dsim_platform_data *dsim_pd;
337	struct mipi_dsim_ddi *dsim_ddi;
338	int ret = -EINVAL;
339
f18acdea SK	340	dsim = devm_kzalloc(&pdev->dev, sizeof(struct mipi_dsim_device),
f18acdea SK	341	GFP_KERNEL);
7258cc14 DL	342	if (!dsim) {
	343	dev_err(&pdev->dev, "failed to allocate dsim object.\n");
	344	return -ENOMEM;
	345	}
	346
	347	dsim->pd = to_dsim_plat(pdev);
	348	dsim->dev = &pdev->dev;
	349	dsim->id = pdev->id;
	350
	351	/* get mipi_dsim_platform_data. */
	352	dsim_pd = (struct mipi_dsim_platform_data *)dsim->pd;
	353	if (dsim_pd == NULL) {
	354	dev_err(&pdev->dev, "failed to get platform data for dsim.\n");
f18acdea	355	return -EINVAL;
7258cc14 DL	356	}
	357	/* get mipi_dsim_config. */
	358	dsim_config = dsim_pd->dsim_config;
	359	if (dsim_config == NULL) {
	360	dev_err(&pdev->dev, "failed to get dsim config data.\n");
f18acdea	361	return -EINVAL;
7258cc14 DL	362	}
	363
	364	dsim->dsim_config = dsim_config;
	365	dsim->master_ops = &master_ops;
	366
	367	mutex_init(&dsim->lock);
	368
f18acdea SK	369	ret = devm_regulator_bulk_get(&pdev->dev, ARRAY_SIZE(supplies),
f18acdea SK	370	supplies);
7258cc14 DL	371	if (ret) {
7258cc14 DL	372	dev_err(&pdev->dev, "Failed to get regulators: %d\n", ret);
f18acdea	373	return ret;
7258cc14 DL	374	}
7258cc14 DL	375
7e0be9f9 SN	376	dsim->phy = devm_phy_get(&pdev->dev, "dsim");
	377	if (IS_ERR(dsim->phy))
	378	return PTR_ERR(dsim->phy);
	379
f18acdea	380	dsim->clock = devm_clk_get(&pdev->dev, "dsim0");
7258cc14 DL	381	if (IS_ERR(dsim->clock)) {
7258cc14 DL	382	dev_err(&pdev->dev, "failed to get dsim clock source\n");
f18acdea	383	return -ENODEV;
7258cc14 DL	384	}
	385
	386	clk_enable(dsim->clock);
	387
	388	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
7258cc14	389
6637eca3 SK	390	dsim->reg_base = devm_ioremap_resource(&pdev->dev, res);
	391	if (IS_ERR(dsim->reg_base)) {
	392	ret = PTR_ERR(dsim->reg_base);
f18acdea	393	goto error;
7258cc14 DL	394	}
	395
	396	mutex_init(&dsim->lock);
	397
	398	/* bind lcd ddi matched with panel name. */
	399	dsim_ddi = exynos_mipi_dsi_bind_lcd_ddi(dsim, dsim_pd->lcd_panel_name);
	400	if (!dsim_ddi) {
	401	dev_err(&pdev->dev, "mipi_dsim_ddi object not found.\n");
36141e56	402	ret = -EINVAL;
f18acdea	403	goto error;
7258cc14 DL	404	}
7258cc14 DL	405
f059c4b2 AH	406	ret = platform_get_irq(pdev, 0);
f059c4b2 AH	407	if (ret < 0) {
7258cc14	408	dev_err(&pdev->dev, "failed to request dsim irq resource\n");
f18acdea	409	goto error;
7258cc14	410	}
f059c4b2	411	dsim->irq = ret;
7258cc14	412
b89e1399 SN	413	init_completion(&dsim_wr_comp);
	414	init_completion(&dsim_rd_comp);
	415	platform_set_drvdata(pdev, dsim);
	416
f18acdea SK	417	ret = devm_request_irq(&pdev->dev, dsim->irq,
f18acdea SK	418	exynos_mipi_dsi_interrupt_handler,
b89e1399	419	IRQF_SHARED, dev_name(&pdev->dev), dsim);
7258cc14 DL	420	if (ret != 0) {
	421	dev_err(&pdev->dev, "failed to request dsim irq\n");
	422	ret = -EINVAL;
f18acdea	423	goto error;
7258cc14 DL	424	}
7258cc14 DL	425
b89e1399	426	/* enable interrupts */
7258cc14 DL	427	exynos_mipi_dsi_init_interrupt(dsim);
	428
	429	/* initialize mipi-dsi client(lcd panel). */
	430	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->probe)
	431	dsim_ddi->dsim_lcd_drv->probe(dsim_ddi->dsim_lcd_dev);
	432
b89e1399 SN	433	/* in case mipi-dsi has been enabled by bootloader */
	434	if (dsim_pd->enabled) {
	435	exynos_mipi_regulator_enable(dsim);
	436	goto done;
	437	}
7258cc14 DL	438
	439	/* lcd panel power on. */
	440	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->power_on)
	441	dsim_ddi->dsim_lcd_drv->power_on(dsim_ddi->dsim_lcd_dev, 1);
	442
	443	exynos_mipi_regulator_enable(dsim);
	444
	445	/* enable MIPI-DSI PHY. */
7e0be9f9	446	phy_power_on(dsim->phy);
7258cc14 DL	447
	448	exynos_mipi_update_cfg(dsim);
	449
	450	/* set lcd panel sequence commands. */
	451	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->set_sequence)
	452	dsim_ddi->dsim_lcd_drv->set_sequence(dsim_ddi->dsim_lcd_dev);
	453
	454	dsim->suspended = false;
	455
b89e1399	456	done:
7258cc14 DL	457	platform_set_drvdata(pdev, dsim);
7258cc14 DL	458
4907cb7b	459	dev_dbg(&pdev->dev, "%s() completed successfully (%s mode)\n", __func__,
b89e1399	460	dsim_config->e_interface == DSIM_COMMAND ? "CPU" : "RGB");
7258cc14 DL	461
	462	return 0;
	463
f18acdea	464	error:
7258cc14	465	clk_disable(dsim->clock);
7258cc14 DL	466	return ret;
	467	}
	468
48c68c4f	469	static int exynos_mipi_dsi_remove(struct platform_device *pdev)
7258cc14 DL	470	{
	471	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	472	struct mipi_dsim_ddi dsim_ddi, next;
	473	struct mipi_dsim_lcd_driver *dsim_lcd_drv;
	474
7258cc14	475	clk_disable(dsim->clock);
7258cc14 DL	476
	477	list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
	478	if (dsim_ddi) {
	479	if (dsim->id != dsim_ddi->bus_id)
	480	continue;
	481
	482	dsim_lcd_drv = dsim_ddi->dsim_lcd_drv;
	483
	484	if (dsim_lcd_drv->remove)
	485	dsim_lcd_drv->remove(dsim_ddi->dsim_lcd_dev);
	486
	487	kfree(dsim_ddi);
	488	}
	489	}
	490
7258cc14 DL	491	return 0;
	492	}
	493
3bfc9b83 SN	494	#ifdef CONFIG_PM_SLEEP
3bfc9b83 SN	495	static int exynos_mipi_dsi_suspend(struct device *dev)
7258cc14	496	{
3bfc9b83	497	struct platform_device *pdev = to_platform_device(dev);
7258cc14 DL	498	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	499	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	500	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
	501
	502	disable_irq(dsim->irq);
	503
	504	if (dsim->suspended)
	505	return 0;
	506
	507	if (client_drv && client_drv->suspend)
	508	client_drv->suspend(client_dev);
	509
7e0be9f9 SN	510	/* disable MIPI-DSI PHY. */
7e0be9f9 SN	511	phy_power_off(dsim->phy);
7258cc14 DL	512
	513	clk_disable(dsim->clock);
	514
	515	exynos_mipi_regulator_disable(dsim);
	516
	517	dsim->suspended = true;
	518
	519	return 0;
	520	}
	521
3bfc9b83	522	static int exynos_mipi_dsi_resume(struct device *dev)
7258cc14	523	{
3bfc9b83	524	struct platform_device *pdev = to_platform_device(dev);
7258cc14 DL	525	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	526	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	527	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
	528
	529	enable_irq(dsim->irq);
	530
	531	if (!dsim->suspended)
	532	return 0;
	533
	534	/* lcd panel power on. */
	535	if (client_drv && client_drv->power_on)
	536	client_drv->power_on(client_dev, 1);
	537
	538	exynos_mipi_regulator_enable(dsim);
	539
	540	/* enable MIPI-DSI PHY. */
7e0be9f9	541	phy_power_on(dsim->phy);
7258cc14 DL	542
	543	clk_enable(dsim->clock);
	544
	545	exynos_mipi_update_cfg(dsim);
	546
	547	/* set lcd panel sequence commands. */
	548	if (client_drv && client_drv->set_sequence)
	549	client_drv->set_sequence(client_dev);
	550
	551	dsim->suspended = false;
	552
	553	return 0;
	554	}
7258cc14 DL	555	#endif
7258cc14 DL	556
3bfc9b83 SN	557	static const struct dev_pm_ops exynos_mipi_dsi_pm_ops = {
	558	SET_SYSTEM_SLEEP_PM_OPS(exynos_mipi_dsi_suspend, exynos_mipi_dsi_resume)
	559	};
	560
7258cc14 DL	561	static struct platform_driver exynos_mipi_dsi_driver = {
7258cc14 DL	562	.probe = exynos_mipi_dsi_probe,
48c68c4f	563	.remove = exynos_mipi_dsi_remove,
7258cc14 DL	564	.driver = {
7258cc14 DL	565	.name = "exynos-mipi-dsim",
3bfc9b83	566	.pm = &exynos_mipi_dsi_pm_ops,
7258cc14 DL	567	},
	568	};
	569
	570	module_platform_driver(exynos_mipi_dsi_driver);
	571
	572	MODULE_AUTHOR("InKi Dae <inki.dae@samsung.com>");
fe4e4372	573	MODULE_DESCRIPTION("Samsung SoC MIPI-DSI driver");
7258cc14	574	MODULE_LICENSE("GPL");