[deliverable/linux.git] / drivers / video / 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;

}

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;
	}

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

	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",
		   .owner = THIS_MODULE,
		   .pm = &exynos_mipi_dsi_pm_ops,
	},
};

module_platform_driver(exynos_mipi_dsi_driver);

MODULE_AUTHOR("InKi Dae <inki.dae@samsung.com>");
MODULE_DESCRIPTION("Samusung 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	}
	266
4c4ceee0 SK	267	static struct mipi_dsim_ddi *exynos_mipi_dsi_bind_lcd_ddi(
4c4ceee0 SK	268	struct mipi_dsim_device *dsim,
7258cc14 DL	269	const char *name)
	270	{
	271	struct mipi_dsim_ddi dsim_ddi, next;
	272	struct mipi_dsim_lcd_driver *lcd_drv;
	273	struct mipi_dsim_lcd_device *lcd_dev;
	274	int ret;
	275
	276	mutex_lock(&dsim->lock);
	277
	278	list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
	279	lcd_drv = dsim_ddi->dsim_lcd_drv;
	280	lcd_dev = dsim_ddi->dsim_lcd_dev;
	281	if (!lcd_drv \|\| !lcd_dev \|\|
	282	(dsim->id != dsim_ddi->bus_id))
	283	continue;
	284
	285	dev_dbg(dsim->dev, "lcd_drv->id = %d, lcd_dev->id = %d\n",
	286	lcd_drv->id, lcd_dev->id);
	287	dev_dbg(dsim->dev, "lcd_dev->bus_id = %d, dsim->id = %d\n",
	288	lcd_dev->bus_id, dsim->id);
	289
	290	if ((strcmp(lcd_drv->name, name) == 0)) {
	291	lcd_dev->master = dsim;
	292
	293	lcd_dev->dev.parent = dsim->dev;
	294	dev_set_name(&lcd_dev->dev, "%s", lcd_drv->name);
	295
	296	ret = device_register(&lcd_dev->dev);
	297	if (ret < 0) {
	298	dev_err(dsim->dev,
	299	"can't register %s, status %d\n",
	300	dev_name(&lcd_dev->dev), ret);
	301	mutex_unlock(&dsim->lock);
	302
	303	return NULL;
	304	}
	305
	306	dsim->dsim_lcd_dev = lcd_dev;
	307	dsim->dsim_lcd_drv = lcd_drv;
	308
	309	mutex_unlock(&dsim->lock);
	310
	311	return dsim_ddi;
	312	}
	313	}
	314
	315	mutex_unlock(&dsim->lock);
	316
	317	return NULL;
	318	}
	319
	320	/* define MIPI-DSI Master operations. */
	321	static struct mipi_dsim_master_ops master_ops = {
	322	.cmd_read = exynos_mipi_dsi_rd_data,
	323	.cmd_write = exynos_mipi_dsi_wr_data,
	324	.get_dsim_frame_done = exynos_mipi_dsi_get_frame_done_status,
	325	.clear_dsim_frame_done = exynos_mipi_dsi_clear_frame_done,
	326	.set_early_blank_mode = exynos_mipi_dsi_early_blank_mode,
	327	.set_blank_mode = exynos_mipi_dsi_blank_mode,
	328	};
	329
	330	static int exynos_mipi_dsi_probe(struct platform_device *pdev)
	331	{
	332	struct resource *res;
333	struct mipi_dsim_device *dsim;
334	struct mipi_dsim_config *dsim_config;
335	struct mipi_dsim_platform_data *dsim_pd;
336	struct mipi_dsim_ddi *dsim_ddi;
337	int ret = -EINVAL;
338
f18acdea SK	339	dsim = devm_kzalloc(&pdev->dev, sizeof(struct mipi_dsim_device),
f18acdea SK	340	GFP_KERNEL);
7258cc14 DL	341	if (!dsim) {
	342	dev_err(&pdev->dev, "failed to allocate dsim object.\n");
	343	return -ENOMEM;
	344	}
	345
	346	dsim->pd = to_dsim_plat(pdev);
	347	dsim->dev = &pdev->dev;
	348	dsim->id = pdev->id;
	349
	350	/* get mipi_dsim_platform_data. */
	351	dsim_pd = (struct mipi_dsim_platform_data *)dsim->pd;
	352	if (dsim_pd == NULL) {
	353	dev_err(&pdev->dev, "failed to get platform data for dsim.\n");
f18acdea	354	return -EINVAL;
7258cc14 DL	355	}
	356	/* get mipi_dsim_config. */
	357	dsim_config = dsim_pd->dsim_config;
	358	if (dsim_config == NULL) {
	359	dev_err(&pdev->dev, "failed to get dsim config data.\n");
f18acdea	360	return -EINVAL;
7258cc14 DL	361	}
	362
	363	dsim->dsim_config = dsim_config;
	364	dsim->master_ops = &master_ops;
	365
	366	mutex_init(&dsim->lock);
	367
f18acdea SK	368	ret = devm_regulator_bulk_get(&pdev->dev, ARRAY_SIZE(supplies),
f18acdea SK	369	supplies);
7258cc14 DL	370	if (ret) {
7258cc14 DL	371	dev_err(&pdev->dev, "Failed to get regulators: %d\n", ret);
f18acdea	372	return ret;
7258cc14 DL	373	}
7258cc14 DL	374
7e0be9f9 SN	375	dsim->phy = devm_phy_get(&pdev->dev, "dsim");
	376	if (IS_ERR(dsim->phy))
	377	return PTR_ERR(dsim->phy);
	378
f18acdea	379	dsim->clock = devm_clk_get(&pdev->dev, "dsim0");
7258cc14 DL	380	if (IS_ERR(dsim->clock)) {
7258cc14 DL	381	dev_err(&pdev->dev, "failed to get dsim clock source\n");
f18acdea	382	return -ENODEV;
7258cc14 DL	383	}
	384
	385	clk_enable(dsim->clock);
	386
	387	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
7258cc14	388
6637eca3 SK	389	dsim->reg_base = devm_ioremap_resource(&pdev->dev, res);
	390	if (IS_ERR(dsim->reg_base)) {
	391	ret = PTR_ERR(dsim->reg_base);
f18acdea	392	goto error;
7258cc14 DL	393	}
	394
	395	mutex_init(&dsim->lock);
	396
	397	/* bind lcd ddi matched with panel name. */
	398	dsim_ddi = exynos_mipi_dsi_bind_lcd_ddi(dsim, dsim_pd->lcd_panel_name);
	399	if (!dsim_ddi) {
	400	dev_err(&pdev->dev, "mipi_dsim_ddi object not found.\n");
36141e56	401	ret = -EINVAL;
f18acdea	402	goto error;
7258cc14 DL	403	}
	404
	405	dsim->irq = platform_get_irq(pdev, 0);
0c980826	406	if (IS_ERR_VALUE(dsim->irq)) {
7258cc14 DL	407	dev_err(&pdev->dev, "failed to request dsim irq resource\n");
7258cc14 DL	408	ret = -EINVAL;
f18acdea	409	goto error;
7258cc14 DL	410	}
7258cc14 DL	411
b89e1399 SN	412	init_completion(&dsim_wr_comp);
	413	init_completion(&dsim_rd_comp);
	414	platform_set_drvdata(pdev, dsim);
	415
f18acdea SK	416	ret = devm_request_irq(&pdev->dev, dsim->irq,
f18acdea SK	417	exynos_mipi_dsi_interrupt_handler,
b89e1399	418	IRQF_SHARED, dev_name(&pdev->dev), dsim);
7258cc14 DL	419	if (ret != 0) {
	420	dev_err(&pdev->dev, "failed to request dsim irq\n");
	421	ret = -EINVAL;
f18acdea	422	goto error;
7258cc14 DL	423	}
7258cc14 DL	424
b89e1399	425	/* enable interrupts */
7258cc14 DL	426	exynos_mipi_dsi_init_interrupt(dsim);
	427
	428	/* initialize mipi-dsi client(lcd panel). */
	429	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->probe)
	430	dsim_ddi->dsim_lcd_drv->probe(dsim_ddi->dsim_lcd_dev);
	431
b89e1399 SN	432	/* in case mipi-dsi has been enabled by bootloader */
	433	if (dsim_pd->enabled) {
	434	exynos_mipi_regulator_enable(dsim);
	435	goto done;
	436	}
7258cc14 DL	437
	438	/* lcd panel power on. */
	439	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->power_on)
	440	dsim_ddi->dsim_lcd_drv->power_on(dsim_ddi->dsim_lcd_dev, 1);
	441
	442	exynos_mipi_regulator_enable(dsim);
	443
	444	/* enable MIPI-DSI PHY. */
7e0be9f9	445	phy_power_on(dsim->phy);
7258cc14 DL	446
	447	exynos_mipi_update_cfg(dsim);
	448
	449	/* set lcd panel sequence commands. */
	450	if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->set_sequence)
	451	dsim_ddi->dsim_lcd_drv->set_sequence(dsim_ddi->dsim_lcd_dev);
	452
	453	dsim->suspended = false;
	454
b89e1399	455	done:
7258cc14 DL	456	platform_set_drvdata(pdev, dsim);
7258cc14 DL	457
4907cb7b	458	dev_dbg(&pdev->dev, "%s() completed successfully (%s mode)\n", __func__,
b89e1399	459	dsim_config->e_interface == DSIM_COMMAND ? "CPU" : "RGB");
7258cc14 DL	460
	461	return 0;
	462
f18acdea	463	error:
7258cc14	464	clk_disable(dsim->clock);
7258cc14 DL	465	return ret;
	466	}
	467
48c68c4f	468	static int exynos_mipi_dsi_remove(struct platform_device *pdev)
7258cc14 DL	469	{
	470	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	471	struct mipi_dsim_ddi dsim_ddi, next;
	472	struct mipi_dsim_lcd_driver *dsim_lcd_drv;
	473
7258cc14	474	clk_disable(dsim->clock);
7258cc14 DL	475
	476	list_for_each_entry_safe(dsim_ddi, next, &dsim_ddi_list, list) {
	477	if (dsim_ddi) {
	478	if (dsim->id != dsim_ddi->bus_id)
	479	continue;
	480
	481	dsim_lcd_drv = dsim_ddi->dsim_lcd_drv;
	482
	483	if (dsim_lcd_drv->remove)
	484	dsim_lcd_drv->remove(dsim_ddi->dsim_lcd_dev);
	485
	486	kfree(dsim_ddi);
	487	}
	488	}
	489
7258cc14 DL	490	return 0;
	491	}
	492
3bfc9b83 SN	493	#ifdef CONFIG_PM_SLEEP
3bfc9b83 SN	494	static int exynos_mipi_dsi_suspend(struct device *dev)
7258cc14	495	{
3bfc9b83	496	struct platform_device *pdev = to_platform_device(dev);
7258cc14 DL	497	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	498	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	499	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
	500
	501	disable_irq(dsim->irq);
	502
	503	if (dsim->suspended)
	504	return 0;
	505
	506	if (client_drv && client_drv->suspend)
	507	client_drv->suspend(client_dev);
	508
7e0be9f9 SN	509	/* disable MIPI-DSI PHY. */
7e0be9f9 SN	510	phy_power_off(dsim->phy);
7258cc14 DL	511
	512	clk_disable(dsim->clock);
	513
	514	exynos_mipi_regulator_disable(dsim);
	515
	516	dsim->suspended = true;
	517
	518	return 0;
	519	}
	520
3bfc9b83	521	static int exynos_mipi_dsi_resume(struct device *dev)
7258cc14	522	{
3bfc9b83	523	struct platform_device *pdev = to_platform_device(dev);
7258cc14 DL	524	struct mipi_dsim_device *dsim = platform_get_drvdata(pdev);
	525	struct mipi_dsim_lcd_driver *client_drv = dsim->dsim_lcd_drv;
	526	struct mipi_dsim_lcd_device *client_dev = dsim->dsim_lcd_dev;
	527
	528	enable_irq(dsim->irq);
	529
	530	if (!dsim->suspended)
	531	return 0;
	532
	533	/* lcd panel power on. */
	534	if (client_drv && client_drv->power_on)
	535	client_drv->power_on(client_dev, 1);
	536
	537	exynos_mipi_regulator_enable(dsim);
	538
	539	/* enable MIPI-DSI PHY. */
7e0be9f9	540	phy_power_on(dsim->phy);
7258cc14 DL	541
	542	clk_enable(dsim->clock);
	543
	544	exynos_mipi_update_cfg(dsim);
	545
	546	/* set lcd panel sequence commands. */
	547	if (client_drv && client_drv->set_sequence)
	548	client_drv->set_sequence(client_dev);
	549
	550	dsim->suspended = false;
	551
	552	return 0;
	553	}
7258cc14 DL	554	#endif
7258cc14 DL	555
3bfc9b83 SN	556	static const struct dev_pm_ops exynos_mipi_dsi_pm_ops = {
	557	SET_SYSTEM_SLEEP_PM_OPS(exynos_mipi_dsi_suspend, exynos_mipi_dsi_resume)
	558	};
	559
7258cc14 DL	560	static struct platform_driver exynos_mipi_dsi_driver = {
7258cc14 DL	561	.probe = exynos_mipi_dsi_probe,
48c68c4f	562	.remove = exynos_mipi_dsi_remove,
7258cc14 DL	563	.driver = {
	564	.name = "exynos-mipi-dsim",
	565	.owner = THIS_MODULE,
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>");
	573	MODULE_DESCRIPTION("Samusung SoC MIPI-DSI driver");
	574	MODULE_LICENSE("GPL");