Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7258cc14 authored by Donghwa Lee's avatar Donghwa Lee Committed by Florian Tobias Schandinat
Browse files

video: support MIPI-DSI controller driver 



Samsung S5PC210 and EXYNOS SoC platform has MIPI-DSI controller and
MIPI-DSI based LCD Panel could be used with it.  This patch supports
MIPI-DSI driver based Samsung SoC chip.

LCD panel driver based MIPI-DSI should be registered to MIPI-DSI driver at
machine code and LCD panel driver specific function registered to
mipi_dsim_ddi structure at lcd panel init function called system init.  In
the MIPI-DSI driver, find lcd panel driver by using registered lcd panel
name, and then initialize lcd panel driver.

Signed-off-by: default avatarDonghwa Lee <dh09.lee@samsung.com>
Signed-off-by: default avatarInki Dae <inki.dae@samsung.com>
Signed-off-by: default avatarKyungmin Park <kyungmin.park@samsung.com>
Acked-by: default avatarJingoo Han <jg1.han@samsung.com>
Cc: Richard Purdie <rpurdie@rpsys.net>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarFlorian Tobias Schandinat <FlorianSchandinat@gmx.de>
parent 12fa8350

drivers/video/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -2411,7 +2411,7 @@ config FB_PUV3_UNIGFX 


source "drivers/video/omap/Kconfig"

source "drivers/video/omap2/Kconfig"



source "drivers/video/exynos/Kconfig"

source "drivers/video/backlight/Kconfig"



if VT

drivers/video/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -15,6 +15,8 @@ obj-$(CONFIG_VT) += console/ 
obj-$(CONFIG_LOGO)		  += logo/

obj-y				  += backlight/



obj-$(CONFIG_EXYNOS_VIDEO)     += exynos/



obj-$(CONFIG_FB_CFB_FILLRECT)  += cfbfillrect.o

obj-$(CONFIG_FB_CFB_COPYAREA)  += cfbcopyarea.o

obj-$(CONFIG_FB_CFB_IMAGEBLIT) += cfbimgblt.o

drivers/video/exynos/Kconfig

0 → 100644
+22 −0
Original line number Diff line number Diff line 
#

# Exynos Video configuration

#



menuconfig EXYNOS_VIDEO

	bool "Exynos Video driver support"

	help

	  This enables support for EXYNOS Video device.



if EXYNOS_VIDEO



#

# MIPI DSI driver

#



config EXYNOS_MIPI_DSI

	bool "EXYNOS MIPI DSI driver support."

	depends on (ARCH_S5PV210 || ARCH_EXYNOS)

	help

	  This enables support for MIPI-DSI device.



endif # EXYNOS_VIDEO

drivers/video/exynos/Makefile

0 → 100644
+6 −0
Original line number Diff line number Diff line 
#

# Makefile for the exynos video drivers.

#



obj-$(CONFIG_EXYNOS_MIPI_DSI)		+= exynos_mipi_dsi.o exynos_mipi_dsi_common.o \

				     	exynos_mipi_dsi_lowlevel.o

drivers/video/exynos/exynos_mipi_dsi.c

0 → 100644
+600 −0
Original line number Diff line number Diff line 
/* 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/regulator/consumer.h>

#include <linux/pm_runtime.h>



#include <video/exynos_mipi_dsim.h>



#include <plat/fb.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 = "vdd10", },

	{ .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);



	/*

	 * data from Display controller(FIMD) is transferred in video mode

	 * but in case of command mode, all settigs is 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 platform_device *pdev = to_platform_device(dsim->dev);

	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_disable(dsim);



		/* enable MIPI-DSI PHY. */

		if (dsim->pd->phy_enable)

			dsim->pd->phy_enable(pdev, true);



		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;

}



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;



}



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 = kzalloc(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");

		goto err_clock_get;

	}

	/* 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");

		goto err_clock_get;

	}



	dsim->dsim_config = dsim_config;

	dsim->master_ops = &master_ops;



	mutex_init(&dsim->lock);



	ret = regulator_bulk_get(&pdev->dev, ARRAY_SIZE(supplies), supplies);

	if (ret) {

		dev_err(&pdev->dev, "Failed to get regulators: %d\n", ret);

		goto err_clock_get;

	}



	dsim->clock = clk_get(&pdev->dev, "dsim0");

	if (IS_ERR(dsim->clock)) {

		dev_err(&pdev->dev, "failed to get dsim clock source\n");

		goto err_clock_get;

	}



	clk_enable(dsim->clock);



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!res) {

		dev_err(&pdev->dev, "failed to get io memory region\n");

		goto err_platform_get;

	}



	dsim->res = request_mem_region(res->start, resource_size(res),

					dev_name(&pdev->dev));

	if (!dsim->res) {

		dev_err(&pdev->dev, "failed to request io memory region\n");

		ret = -ENOMEM;

		goto err_mem_region;

	}



	dsim->reg_base = ioremap(res->start, resource_size(res));

	if (!dsim->reg_base) {

		dev_err(&pdev->dev, "failed to remap io region\n");

		ret = -ENOMEM;

		goto err_ioremap;

	}



	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");

		goto err_bind;

	}



	dsim->irq = platform_get_irq(pdev, 0);

	if (dsim->irq < 0) {

		dev_err(&pdev->dev, "failed to request dsim irq resource\n");

		ret = -EINVAL;

		goto err_platform_get_irq;

	}



	ret = request_irq(dsim->irq, exynos_mipi_dsi_interrupt_handler,

			IRQF_SHARED, pdev->name, dsim);

	if (ret != 0) {

		dev_err(&pdev->dev, "failed to request dsim irq\n");

		ret = -EINVAL;

		goto err_bind;

	}



	init_completion(&dsim_wr_comp);

	init_completion(&dsim_rd_comp);



	/* enable interrupt */

	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 that mipi got enabled at bootloader. */

	if (dsim_pd->enabled)

		goto out;



	/* 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. */

	if (dsim->pd->phy_enable)

		dsim->pd->phy_enable(pdev, true);



	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;



out:

	platform_set_drvdata(pdev, dsim);



	dev_dbg(&pdev->dev, "mipi-dsi driver(%s mode) has been probed.\n",

		(dsim_config->e_interface == DSIM_COMMAND) ?

			"CPU" : "RGB");



	return 0;



err_bind:

	iounmap(dsim->reg_base);



err_ioremap:

	release_mem_region(dsim->res->start, resource_size(dsim->res));



err_mem_region:

	release_resource(dsim->res);



err_platform_get:

	clk_disable(dsim->clock);

	clk_put(dsim->clock);

err_clock_get:

	kfree(dsim);



err_platform_get_irq:

	return ret;

}



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



	iounmap(dsim->reg_base);



	clk_disable(dsim->clock);

	clk_put(dsim->clock);



	release_resource(dsim->res);

	release_mem_region(dsim->res->start, resource_size(dsim->res));



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

		}

	}



	regulator_bulk_free(ARRAY_SIZE(supplies), supplies);

	kfree(dsim);



	return 0;

}



#ifdef CONFIG_PM

static int exynos_mipi_dsi_suspend(struct platform_device *pdev,

		pm_message_t state)

{

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



	/* enable MIPI-DSI PHY. */

	if (dsim->pd->phy_enable)

		dsim->pd->phy_enable(pdev, false);



	clk_disable(dsim->clock);



	exynos_mipi_regulator_disable(dsim);



	dsim->suspended = true;



	return 0;

}



static int exynos_mipi_dsi_resume(struct platform_device *pdev)

{

	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. */

	if (dsim->pd->phy_enable)

		dsim->pd->phy_enable(pdev, true);



	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;

}

#else

#define exynos_mipi_dsi_suspend NULL

#define exynos_mipi_dsi_resume NULL

#endif



static struct platform_driver exynos_mipi_dsi_driver = {

	.probe = exynos_mipi_dsi_probe,

	.remove = __devexit_p(exynos_mipi_dsi_remove),

	.suspend = exynos_mipi_dsi_suspend,

	.resume = exynos_mipi_dsi_resume,

	.driver = {

		   .name = "exynos-mipi-dsim",

		   .owner = THIS_MODULE,

	},

};



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");