[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / video / omap2 / dss / core.c

/*
 * linux/drivers/video/omap2/dss/core.c
 *
 * Copyright (C) 2009 Nokia Corporation
 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
 *
 * Some code and ideas taken from drivers/video/omap/ driver
 * by Imre Deak.
 *
 * 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.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#define DSS_SUBSYS_NAME "CORE"

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/seq_file.h>
#include <linux/debugfs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/regulator/consumer.h>
#include <linux/suspend.h>
#include <linux/slab.h>

#include <video/omapdss.h>

#include "dss.h"
#include "dss_features.h"

static struct {
	struct platform_device *pdev;

	struct regulator *vdds_dsi_reg;
	struct regulator *vdds_sdi_reg;

	const char *default_display_name;
} core;

static char *def_disp_name;
module_param_named(def_disp, def_disp_name, charp, 0);
MODULE_PARM_DESC(def_disp, "default display name");

static bool dss_initialized;

const char *omapdss_get_default_display_name(void)
{
	return core.default_display_name;
}
EXPORT_SYMBOL(omapdss_get_default_display_name);

enum omapdss_version omapdss_get_version(void)
{
	struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
	return pdata->version;
}
EXPORT_SYMBOL(omapdss_get_version);

bool omapdss_is_initialized(void)
{
	return dss_initialized;
}
EXPORT_SYMBOL(omapdss_is_initialized);

struct platform_device *dss_get_core_pdev(void)
{
	return core.pdev;
}

/* REGULATORS */

struct regulator *dss_get_vdds_dsi(void)
{
	struct regulator *reg;

	if (core.vdds_dsi_reg != NULL)
		return core.vdds_dsi_reg;

	reg = regulator_get(&core.pdev->dev, "vdds_dsi");
	if (!IS_ERR(reg))
		core.vdds_dsi_reg = reg;

	return reg;
}

struct regulator *dss_get_vdds_sdi(void)
{
	struct regulator *reg;

	if (core.vdds_sdi_reg != NULL)
		return core.vdds_sdi_reg;

	reg = regulator_get(&core.pdev->dev, "vdds_sdi");
	if (!IS_ERR(reg))
		core.vdds_sdi_reg = reg;

	return reg;
}

int dss_dsi_enable_pads(int dsi_id, unsigned lane_mask)
{
	struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;

	if (!board_data->dsi_enable_pads)
		return -ENOENT;

	return board_data->dsi_enable_pads(dsi_id, lane_mask);
}

void dss_dsi_disable_pads(int dsi_id, unsigned lane_mask)
{
	struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;

	if (!board_data->dsi_disable_pads)
		return;

	return board_data->dsi_disable_pads(dsi_id, lane_mask);
}

int dss_set_min_bus_tput(struct device *dev, unsigned long tput)
{
	struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;

	if (pdata->set_min_bus_tput)
		return pdata->set_min_bus_tput(dev, tput);
	else
		return 0;
}

#if defined(CONFIG_OMAP2_DSS_DEBUGFS)
static int dss_debug_show(struct seq_file *s, void *unused)
{
	void (*func)(struct seq_file *) = s->private;
	func(s);
	return 0;
}

static int dss_debug_open(struct inode *inode, struct file *file)
{
	return single_open(file, dss_debug_show, inode->i_private);
}

static const struct file_operations dss_debug_fops = {
	.open           = dss_debug_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
	.release        = single_release,
};

static struct dentry *dss_debugfs_dir;

static int dss_initialize_debugfs(void)
{
	dss_debugfs_dir = debugfs_create_dir("omapdss", NULL);
	if (IS_ERR(dss_debugfs_dir)) {
		int err = PTR_ERR(dss_debugfs_dir);
		dss_debugfs_dir = NULL;
		return err;
	}

	debugfs_create_file("clk", S_IRUGO, dss_debugfs_dir,
			&dss_debug_dump_clocks, &dss_debug_fops);

	return 0;
}

static void dss_uninitialize_debugfs(void)
{
	if (dss_debugfs_dir)
		debugfs_remove_recursive(dss_debugfs_dir);
}

int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *))
{
	struct dentry *d;

	d = debugfs_create_file(name, S_IRUGO, dss_debugfs_dir,
			write, &dss_debug_fops);

	return PTR_RET(d);
}
#else /* CONFIG_OMAP2_DSS_DEBUGFS */
static inline int dss_initialize_debugfs(void)
{
	return 0;
}
static inline void dss_uninitialize_debugfs(void)
{
}
int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *))
{
	return 0;
}
#endif /* CONFIG_OMAP2_DSS_DEBUGFS */

/* PLATFORM DEVICE */
static int omap_dss_pm_notif(struct notifier_block *b, unsigned long v, void *d)
{
	DSSDBG("pm notif %lu\n", v);

	switch (v) {
	case PM_SUSPEND_PREPARE:
		DSSDBG("suspending displays\n");
		return dss_suspend_all_devices();

	case PM_POST_SUSPEND:
		DSSDBG("resuming displays\n");
		return dss_resume_all_devices();

	default:
		return 0;
	}
}

static struct notifier_block omap_dss_pm_notif_block = {
	.notifier_call = omap_dss_pm_notif,
};

static int __init omap_dss_probe(struct platform_device *pdev)
{
	struct omap_dss_board_info *pdata = pdev->dev.platform_data;
	int r;

	core.pdev = pdev;

	dss_features_init(omapdss_get_version());

	r = dss_initialize_debugfs();
	if (r)
		goto err_debugfs;

	if (def_disp_name)
		core.default_display_name = def_disp_name;
	else if (pdata->default_device)
		core.default_display_name = pdata->default_device->name;

	register_pm_notifier(&omap_dss_pm_notif_block);

	return 0;

err_debugfs:

	return r;
}

static int omap_dss_remove(struct platform_device *pdev)
{
	unregister_pm_notifier(&omap_dss_pm_notif_block);

	dss_uninitialize_debugfs();

	return 0;
}

static void omap_dss_shutdown(struct platform_device *pdev)
{
	DSSDBG("shutdown\n");
	dss_disable_all_devices();
}

static struct platform_driver omap_dss_driver = {
	.remove         = omap_dss_remove,
	.shutdown	= omap_dss_shutdown,
	.driver         = {
		.name   = "omapdss",
		.owner  = THIS_MODULE,
	},
};

/* BUS */
static int dss_bus_match(struct device *dev, struct device_driver *driver)
{
	struct omap_dss_device *dssdev = to_dss_device(dev);

	DSSDBG("bus_match. dev %s/%s, drv %s\n",
			dev_name(dev), dssdev->driver_name, driver->name);

	return strcmp(dssdev->driver_name, driver->name) == 0;
}

static ssize_t device_name_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct omap_dss_device *dssdev = to_dss_device(dev);
	return snprintf(buf, PAGE_SIZE, "%s\n",
			dssdev->name ?
			dssdev->name : "");
}

static struct device_attribute default_dev_attrs[] = {
	__ATTR(name, S_IRUGO, device_name_show, NULL),
	__ATTR_NULL,
};

static ssize_t driver_name_show(struct device_driver *drv, char *buf)
{
	struct omap_dss_driver *dssdrv = to_dss_driver(drv);
	return snprintf(buf, PAGE_SIZE, "%s\n",
			dssdrv->driver.name ?
			dssdrv->driver.name : "");
}
static struct driver_attribute default_drv_attrs[] = {
	__ATTR(name, S_IRUGO, driver_name_show, NULL),
	__ATTR_NULL,
};

static struct bus_type dss_bus_type = {
	.name = "omapdss",
	.match = dss_bus_match,
	.dev_attrs = default_dev_attrs,
	.drv_attrs = default_drv_attrs,
};

static void dss_bus_release(struct device *dev)
{
	DSSDBG("bus_release\n");
}

static struct device dss_bus = {
	.release = dss_bus_release,
};

struct bus_type *dss_get_bus(void)
{
	return &dss_bus_type;
}

/* DRIVER */
static int dss_driver_probe(struct device *dev)
{
	int r;
	struct omap_dss_driver *dssdrv = to_dss_driver(dev->driver);
	struct omap_dss_device *dssdev = to_dss_device(dev);

	DSSDBG("driver_probe: dev %s/%s, drv %s\n",
				dev_name(dev), dssdev->driver_name,
				dssdrv->driver.name);

	r = dssdrv->probe(dssdev);

	if (r) {
		DSSERR("driver probe failed: %d\n", r);
		return r;
	}

	DSSDBG("probe done for device %s\n", dev_name(dev));

	dssdev->driver = dssdrv;

	return 0;
}

static int dss_driver_remove(struct device *dev)
{
	struct omap_dss_driver *dssdrv = to_dss_driver(dev->driver);
	struct omap_dss_device *dssdev = to_dss_device(dev);

	DSSDBG("driver_remove: dev %s/%s\n", dev_name(dev),
			dssdev->driver_name);

	dssdrv->remove(dssdev);

	dssdev->driver = NULL;

	return 0;
}

int omap_dss_register_driver(struct omap_dss_driver *dssdriver)
{
	dssdriver->driver.bus = &dss_bus_type;
	dssdriver->driver.probe = dss_driver_probe;
	dssdriver->driver.remove = dss_driver_remove;

	if (dssdriver->get_resolution == NULL)
		dssdriver->get_resolution = omapdss_default_get_resolution;
	if (dssdriver->get_recommended_bpp == NULL)
		dssdriver->get_recommended_bpp =
			omapdss_default_get_recommended_bpp;
	if (dssdriver->get_timings == NULL)
		dssdriver->get_timings = omapdss_default_get_timings;

	return driver_register(&dssdriver->driver);
}
EXPORT_SYMBOL(omap_dss_register_driver);

void omap_dss_unregister_driver(struct omap_dss_driver *dssdriver)
{
	driver_unregister(&dssdriver->driver);
}
EXPORT_SYMBOL(omap_dss_unregister_driver);

/* DEVICE */

static void omap_dss_dev_release(struct device *dev)
{
	struct omap_dss_device *dssdev = to_dss_device(dev);
	kfree(dssdev);
}

static int disp_num_counter;

struct omap_dss_device *dss_alloc_and_init_device(struct device *parent)
{
	struct omap_dss_device *dssdev;

	dssdev = kzalloc(sizeof(*dssdev), GFP_KERNEL);
	if (!dssdev)
		return NULL;

	dssdev->dev.bus = &dss_bus_type;
	dssdev->dev.parent = parent;
	dssdev->dev.release = omap_dss_dev_release;
	dev_set_name(&dssdev->dev, "display%d", disp_num_counter++);

	device_initialize(&dssdev->dev);

	return dssdev;
}

int dss_add_device(struct omap_dss_device *dssdev)
{
	return device_add(&dssdev->dev);
}

void dss_put_device(struct omap_dss_device *dssdev)
{
	put_device(&dssdev->dev);
}

void dss_unregister_device(struct omap_dss_device *dssdev)
{
	device_unregister(&dssdev->dev);
}

static int dss_unregister_dss_dev(struct device *dev, void *data)
{
	struct omap_dss_device *dssdev = to_dss_device(dev);
	dss_unregister_device(dssdev);
	return 0;
}

void dss_unregister_child_devices(struct device *parent)
{
	device_for_each_child(parent, NULL, dss_unregister_dss_dev);
}

void dss_copy_device_pdata(struct omap_dss_device *dst,
		const struct omap_dss_device *src)
{
	u8 *d = (u8 *)dst;
	u8 *s = (u8 *)src;
	size_t dsize = sizeof(struct device);

	memcpy(d + dsize, s + dsize, sizeof(struct omap_dss_device) - dsize);
}

/* BUS */
static int __init omap_dss_bus_register(void)
{
	int r;

	r = bus_register(&dss_bus_type);
	if (r) {
		DSSERR("bus register failed\n");
		return r;
	}

	dev_set_name(&dss_bus, "omapdss");
	r = device_register(&dss_bus);
	if (r) {
		DSSERR("bus driver register failed\n");
		bus_unregister(&dss_bus_type);
		return r;
	}

	return 0;
}

/* INIT */
static int (*dss_output_drv_reg_funcs[])(void) __initdata = {
#ifdef CONFIG_OMAP2_DSS_DSI
	dsi_init_platform_driver,
#endif
#ifdef CONFIG_OMAP2_DSS_DPI
	dpi_init_platform_driver,
#endif
#ifdef CONFIG_OMAP2_DSS_SDI
	sdi_init_platform_driver,
#endif
#ifdef CONFIG_OMAP2_DSS_RFBI
	rfbi_init_platform_driver,
#endif
#ifdef CONFIG_OMAP2_DSS_VENC
	venc_init_platform_driver,
#endif
#ifdef CONFIG_OMAP4_DSS_HDMI
	hdmi_init_platform_driver,
#endif
};

static void (*dss_output_drv_unreg_funcs[])(void) __exitdata = {
#ifdef CONFIG_OMAP2_DSS_DSI
	dsi_uninit_platform_driver,
#endif
#ifdef CONFIG_OMAP2_DSS_DPI
	dpi_uninit_platform_driver,
#endif
#ifdef CONFIG_OMAP2_DSS_SDI
	sdi_uninit_platform_driver,
#endif
#ifdef CONFIG_OMAP2_DSS_RFBI
	rfbi_uninit_platform_driver,
#endif
#ifdef CONFIG_OMAP2_DSS_VENC
	venc_uninit_platform_driver,
#endif
#ifdef CONFIG_OMAP4_DSS_HDMI
	hdmi_uninit_platform_driver,
#endif
};

static bool dss_output_drv_loaded[ARRAY_SIZE(dss_output_drv_reg_funcs)];

static int __init omap_dss_register_drivers(void)
{
	int r;
	int i;

	r = platform_driver_probe(&omap_dss_driver, omap_dss_probe);
	if (r)
		return r;

	r = dss_init_platform_driver();
	if (r) {
		DSSERR("Failed to initialize DSS platform driver\n");
		goto err_dss;
	}

	r = dispc_init_platform_driver();
	if (r) {
		DSSERR("Failed to initialize dispc platform driver\n");
		goto err_dispc;
	}

	/*
	 * It's ok if the output-driver register fails. It happens, for example,
	 * when there is no output-device (e.g. SDI for OMAP4).
	 */
	for (i = 0; i < ARRAY_SIZE(dss_output_drv_reg_funcs); ++i) {
		r = dss_output_drv_reg_funcs[i]();
		if (r == 0)
			dss_output_drv_loaded[i] = true;
	}

	return 0;

err_dispc:
	dss_uninit_platform_driver();
err_dss:
	platform_driver_unregister(&omap_dss_driver);

	return r;
}

static void __exit omap_dss_unregister_drivers(void)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(dss_output_drv_unreg_funcs); ++i) {
		if (dss_output_drv_loaded[i])
			dss_output_drv_unreg_funcs[i]();
	}

	dispc_uninit_platform_driver();
	dss_uninit_platform_driver();

	platform_driver_unregister(&omap_dss_driver);
}

#ifdef CONFIG_OMAP2_DSS_MODULE
static void omap_dss_bus_unregister(void)
{
	device_unregister(&dss_bus);

	bus_unregister(&dss_bus_type);
}

static int __init omap_dss_init(void)
{
	int r;

	r = omap_dss_bus_register();
	if (r)
		return r;

	r = omap_dss_register_drivers();
	if (r) {
		omap_dss_bus_unregister();
		return r;
	}

	dss_initialized = true;

	return 0;
}

static void __exit omap_dss_exit(void)
{
	if (core.vdds_dsi_reg != NULL) {
		regulator_put(core.vdds_dsi_reg);
		core.vdds_dsi_reg = NULL;
	}

	if (core.vdds_sdi_reg != NULL) {
		regulator_put(core.vdds_sdi_reg);
		core.vdds_sdi_reg = NULL;
	}

	omap_dss_unregister_drivers();

	omap_dss_bus_unregister();
}

module_init(omap_dss_init);
module_exit(omap_dss_exit);
#else
static int __init omap_dss_init(void)
{
	return omap_dss_bus_register();
}

static int __init omap_dss_init2(void)
{
	int r;

	r = omap_dss_register_drivers();
	if (r)
		return r;

	dss_initialized = true;

	return 0;
}

core_initcall(omap_dss_init);
device_initcall(omap_dss_init2);
#endif

MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
MODULE_DESCRIPTION("OMAP2/3 Display Subsystem");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
	1	/*
	2	* linux/drivers/video/omap2/dss/core.c
	3	*
	4	* Copyright (C) 2009 Nokia Corporation
	5	* Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
	6	*
	7	* Some code and ideas taken from drivers/video/omap/ driver
	8	* by Imre Deak.
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License version 2 as published by
	12	* the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope that it will be useful, but WITHOUT
	15	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	16	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	17	* more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along with
	20	* this program. If not, see <http://www.gnu.org/licenses/>.
	21	*/
	22
	23	#define DSS_SUBSYS_NAME "CORE"
	24
	25	#include <linux/kernel.h>
	26	#include <linux/module.h>
	27	#include <linux/clk.h>
	28	#include <linux/err.h>
	29	#include <linux/platform_device.h>
	30	#include <linux/seq_file.h>
	31	#include <linux/debugfs.h>
	32	#include <linux/io.h>
	33	#include <linux/device.h>
	34	#include <linux/regulator/consumer.h>
	35	#include <linux/suspend.h>
	36	#include <linux/slab.h>
	37
	38	#include <video/omapdss.h>
	39
	40	#include "dss.h"
	41	#include "dss_features.h"
	42
	43	static struct {
	44	struct platform_device *pdev;
	45
	46	struct regulator *vdds_dsi_reg;
	47	struct regulator *vdds_sdi_reg;
	48
	49	const char *default_display_name;
	50	} core;
	51
	52	static char *def_disp_name;
	53	module_param_named(def_disp, def_disp_name, charp, 0);
	54	MODULE_PARM_DESC(def_disp, "default display name");
	55
	56	static bool dss_initialized;
	57
	58	const char *omapdss_get_default_display_name(void)
	59	{
	60	return core.default_display_name;
	61	}
	62	EXPORT_SYMBOL(omapdss_get_default_display_name);
	63
	64	enum omapdss_version omapdss_get_version(void)
	65	{
	66	struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
	67	return pdata->version;
	68	}
	69	EXPORT_SYMBOL(omapdss_get_version);
	70
	71	bool omapdss_is_initialized(void)
	72	{
	73	return dss_initialized;
	74	}
	75	EXPORT_SYMBOL(omapdss_is_initialized);
	76
	77	struct platform_device *dss_get_core_pdev(void)
	78	{
	79	return core.pdev;
	80	}
	81
	82	/* REGULATORS */
	83
	84	struct regulator *dss_get_vdds_dsi(void)
	85	{
	86	struct regulator *reg;
	87
	88	if (core.vdds_dsi_reg != NULL)
	89	return core.vdds_dsi_reg;
	90
	91	reg = regulator_get(&core.pdev->dev, "vdds_dsi");
	92	if (!IS_ERR(reg))
	93	core.vdds_dsi_reg = reg;
	94
	95	return reg;
	96	}
	97
	98	struct regulator *dss_get_vdds_sdi(void)
	99	{
	100	struct regulator *reg;
	101
	102	if (core.vdds_sdi_reg != NULL)
	103	return core.vdds_sdi_reg;
	104
	105	reg = regulator_get(&core.pdev->dev, "vdds_sdi");
	106	if (!IS_ERR(reg))
	107	core.vdds_sdi_reg = reg;
	108
	109	return reg;
	110	}
	111
	112	int dss_dsi_enable_pads(int dsi_id, unsigned lane_mask)
	113	{
	114	struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;
	115
	116	if (!board_data->dsi_enable_pads)
	117	return -ENOENT;
	118
	119	return board_data->dsi_enable_pads(dsi_id, lane_mask);
	120	}
	121
	122	void dss_dsi_disable_pads(int dsi_id, unsigned lane_mask)
	123	{
	124	struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;
	125
	126	if (!board_data->dsi_disable_pads)
	127	return;
	128
	129	return board_data->dsi_disable_pads(dsi_id, lane_mask);
	130	}
	131
	132	int dss_set_min_bus_tput(struct device *dev, unsigned long tput)
	133	{
	134	struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
	135
	136	if (pdata->set_min_bus_tput)
	137	return pdata->set_min_bus_tput(dev, tput);
	138	else
	139	return 0;
	140	}
	141
	142	#if defined(CONFIG_OMAP2_DSS_DEBUGFS)
	143	static int dss_debug_show(struct seq_file s, void unused)
	144	{
	145	void (func)(struct seq_file ) = s->private;
	146	func(s);
	147	return 0;
	148	}
	149
	150	static int dss_debug_open(struct inode inode, struct file file)
	151	{
	152	return single_open(file, dss_debug_show, inode->i_private);
	153	}
	154
	155	static const struct file_operations dss_debug_fops = {
	156	.open = dss_debug_open,
	157	.read = seq_read,
	158	.llseek = seq_lseek,
	159	.release = single_release,
	160	};
	161
	162	static struct dentry *dss_debugfs_dir;
	163
	164	static int dss_initialize_debugfs(void)
	165	{
	166	dss_debugfs_dir = debugfs_create_dir("omapdss", NULL);
	167	if (IS_ERR(dss_debugfs_dir)) {
	168	int err = PTR_ERR(dss_debugfs_dir);
	169	dss_debugfs_dir = NULL;
	170	return err;
	171	}
	172
	173	debugfs_create_file("clk", S_IRUGO, dss_debugfs_dir,
	174	&dss_debug_dump_clocks, &dss_debug_fops);
	175
	176	return 0;
	177	}
	178
	179	static void dss_uninitialize_debugfs(void)
	180	{
	181	if (dss_debugfs_dir)
	182	debugfs_remove_recursive(dss_debugfs_dir);
	183	}
	184
	185	int dss_debugfs_create_file(const char name, void (write)(struct seq_file *))
	186	{
	187	struct dentry *d;
	188
	189	d = debugfs_create_file(name, S_IRUGO, dss_debugfs_dir,
	190	write, &dss_debug_fops);
	191
	192	return PTR_RET(d);
	193	}
	194	#else /* CONFIG_OMAP2_DSS_DEBUGFS */
	195	static inline int dss_initialize_debugfs(void)
	196	{
	197	return 0;
	198	}
	199	static inline void dss_uninitialize_debugfs(void)
	200	{
	201	}
	202	int dss_debugfs_create_file(const char name, void (write)(struct seq_file *))
	203	{
	204	return 0;
	205	}
	206	#endif /* CONFIG_OMAP2_DSS_DEBUGFS */
	207
	208	/* PLATFORM DEVICE */
	209	static int omap_dss_pm_notif(struct notifier_block b, unsigned long v, void d)
	210	{
	211	DSSDBG("pm notif %lu\n", v);
	212
	213	switch (v) {
	214	case PM_SUSPEND_PREPARE:
	215	DSSDBG("suspending displays\n");
	216	return dss_suspend_all_devices();
	217
	218	case PM_POST_SUSPEND:
	219	DSSDBG("resuming displays\n");
	220	return dss_resume_all_devices();
	221
	222	default:
	223	return 0;
	224	}
	225	}
	226
	227	static struct notifier_block omap_dss_pm_notif_block = {
	228	.notifier_call = omap_dss_pm_notif,
	229	};
	230
	231	static int __init omap_dss_probe(struct platform_device *pdev)
	232	{
	233	struct omap_dss_board_info *pdata = pdev->dev.platform_data;
	234	int r;
	235
	236	core.pdev = pdev;
	237
	238	dss_features_init(omapdss_get_version());
	239
	240	r = dss_initialize_debugfs();
	241	if (r)
	242	goto err_debugfs;
	243
	244	if (def_disp_name)
	245	core.default_display_name = def_disp_name;
	246	else if (pdata->default_device)
	247	core.default_display_name = pdata->default_device->name;
	248
	249	register_pm_notifier(&omap_dss_pm_notif_block);
	250
	251	return 0;
	252
	253	err_debugfs:
	254
	255	return r;
	256	}
	257
	258	static int omap_dss_remove(struct platform_device *pdev)
	259	{
	260	unregister_pm_notifier(&omap_dss_pm_notif_block);
	261
	262	dss_uninitialize_debugfs();
	263
	264	return 0;
	265	}
	266
	267	static void omap_dss_shutdown(struct platform_device *pdev)
	268	{
	269	DSSDBG("shutdown\n");
	270	dss_disable_all_devices();
	271	}
	272
	273	static struct platform_driver omap_dss_driver = {
	274	.remove = omap_dss_remove,
	275	.shutdown = omap_dss_shutdown,
	276	.driver = {
	277	.name = "omapdss",
	278	.owner = THIS_MODULE,
	279	},
	280	};
	281
	282	/* BUS */
	283	static int dss_bus_match(struct device dev, struct device_driver driver)
	284	{
	285	struct omap_dss_device *dssdev = to_dss_device(dev);
	286
	287	DSSDBG("bus_match. dev %s/%s, drv %s\n",
	288	dev_name(dev), dssdev->driver_name, driver->name);
	289
	290	return strcmp(dssdev->driver_name, driver->name) == 0;
	291	}
	292
	293	static ssize_t device_name_show(struct device *dev,
	294	struct device_attribute attr, char buf)
	295	{
	296	struct omap_dss_device *dssdev = to_dss_device(dev);
	297	return snprintf(buf, PAGE_SIZE, "%s\n",
	298	dssdev->name ?
	299	dssdev->name : "");
	300	}
	301
	302	static struct device_attribute default_dev_attrs[] = {
	303	__ATTR(name, S_IRUGO, device_name_show, NULL),
	304	__ATTR_NULL,
	305	};
	306
	307	static ssize_t driver_name_show(struct device_driver drv, char buf)
	308	{
	309	struct omap_dss_driver *dssdrv = to_dss_driver(drv);
	310	return snprintf(buf, PAGE_SIZE, "%s\n",
	311	dssdrv->driver.name ?
	312	dssdrv->driver.name : "");
	313	}
	314	static struct driver_attribute default_drv_attrs[] = {
	315	__ATTR(name, S_IRUGO, driver_name_show, NULL),
	316	__ATTR_NULL,
	317	};
	318
	319	static struct bus_type dss_bus_type = {
	320	.name = "omapdss",
	321	.match = dss_bus_match,
	322	.dev_attrs = default_dev_attrs,
	323	.drv_attrs = default_drv_attrs,
	324	};
	325
	326	static void dss_bus_release(struct device *dev)
	327	{
	328	DSSDBG("bus_release\n");
	329	}
	330
	331	static struct device dss_bus = {
	332	.release = dss_bus_release,
	333	};
	334
	335	struct bus_type *dss_get_bus(void)
	336	{
	337	return &dss_bus_type;
	338	}
	339
	340	/* DRIVER */
	341	static int dss_driver_probe(struct device *dev)
	342	{
	343	int r;
	344	struct omap_dss_driver *dssdrv = to_dss_driver(dev->driver);
	345	struct omap_dss_device *dssdev = to_dss_device(dev);
	346
	347	DSSDBG("driver_probe: dev %s/%s, drv %s\n",
	348	dev_name(dev), dssdev->driver_name,
	349	dssdrv->driver.name);
	350
	351	r = dssdrv->probe(dssdev);
	352
	353	if (r) {
	354	DSSERR("driver probe failed: %d\n", r);
	355	return r;
	356	}
	357
	358	DSSDBG("probe done for device %s\n", dev_name(dev));
	359
	360	dssdev->driver = dssdrv;
	361
	362	return 0;
	363	}
	364
	365	static int dss_driver_remove(struct device *dev)
	366	{
	367	struct omap_dss_driver *dssdrv = to_dss_driver(dev->driver);
	368	struct omap_dss_device *dssdev = to_dss_device(dev);
	369
	370	DSSDBG("driver_remove: dev %s/%s\n", dev_name(dev),
	371	dssdev->driver_name);
	372
	373	dssdrv->remove(dssdev);
	374
	375	dssdev->driver = NULL;
	376
	377	return 0;
	378	}
	379
	380	int omap_dss_register_driver(struct omap_dss_driver *dssdriver)
	381	{
	382	dssdriver->driver.bus = &dss_bus_type;
	383	dssdriver->driver.probe = dss_driver_probe;
	384	dssdriver->driver.remove = dss_driver_remove;
	385
	386	if (dssdriver->get_resolution == NULL)
	387	dssdriver->get_resolution = omapdss_default_get_resolution;
	388	if (dssdriver->get_recommended_bpp == NULL)
	389	dssdriver->get_recommended_bpp =
	390	omapdss_default_get_recommended_bpp;
	391	if (dssdriver->get_timings == NULL)
	392	dssdriver->get_timings = omapdss_default_get_timings;
	393
	394	return driver_register(&dssdriver->driver);
	395	}
	396	EXPORT_SYMBOL(omap_dss_register_driver);
	397
	398	void omap_dss_unregister_driver(struct omap_dss_driver *dssdriver)
	399	{
	400	driver_unregister(&dssdriver->driver);
	401	}
	402	EXPORT_SYMBOL(omap_dss_unregister_driver);
	403
	404	/* DEVICE */
	405
	406	static void omap_dss_dev_release(struct device *dev)
	407	{
	408	struct omap_dss_device *dssdev = to_dss_device(dev);
	409	kfree(dssdev);
	410	}
	411
	412	static int disp_num_counter;
	413
	414	struct omap_dss_device dss_alloc_and_init_device(struct device parent)
	415	{
	416	struct omap_dss_device *dssdev;
	417
	418	dssdev = kzalloc(sizeof(*dssdev), GFP_KERNEL);
	419	if (!dssdev)
	420	return NULL;
	421
	422	dssdev->dev.bus = &dss_bus_type;
	423	dssdev->dev.parent = parent;
	424	dssdev->dev.release = omap_dss_dev_release;
	425	dev_set_name(&dssdev->dev, "display%d", disp_num_counter++);
	426
	427	device_initialize(&dssdev->dev);
	428
	429	return dssdev;
	430	}
	431
	432	int dss_add_device(struct omap_dss_device *dssdev)
	433	{
	434	return device_add(&dssdev->dev);
	435	}
	436
	437	void dss_put_device(struct omap_dss_device *dssdev)
	438	{
	439	put_device(&dssdev->dev);
	440	}
	441
	442	void dss_unregister_device(struct omap_dss_device *dssdev)
	443	{
	444	device_unregister(&dssdev->dev);
	445	}
	446
	447	static int dss_unregister_dss_dev(struct device dev, void data)
	448	{
	449	struct omap_dss_device *dssdev = to_dss_device(dev);
	450	dss_unregister_device(dssdev);
	451	return 0;
	452	}
	453
	454	void dss_unregister_child_devices(struct device *parent)
	455	{
	456	device_for_each_child(parent, NULL, dss_unregister_dss_dev);
	457	}
	458
	459	void dss_copy_device_pdata(struct omap_dss_device *dst,
	460	const struct omap_dss_device *src)
	461	{
	462	u8 d = (u8 )dst;
	463	u8 s = (u8 )src;
	464	size_t dsize = sizeof(struct device);
	465
	466	memcpy(d + dsize, s + dsize, sizeof(struct omap_dss_device) - dsize);
	467	}
	468
	469	/* BUS */
	470	static int __init omap_dss_bus_register(void)
	471	{
	472	int r;
	473
	474	r = bus_register(&dss_bus_type);
	475	if (r) {
	476	DSSERR("bus register failed\n");
	477	return r;
	478	}
	479
	480	dev_set_name(&dss_bus, "omapdss");
	481	r = device_register(&dss_bus);
	482	if (r) {
	483	DSSERR("bus driver register failed\n");
	484	bus_unregister(&dss_bus_type);
	485	return r;
	486	}
	487
	488	return 0;
	489	}
	490
	491	/* INIT */
	492	static int (*dss_output_drv_reg_funcs[])(void) __initdata = {
	493	#ifdef CONFIG_OMAP2_DSS_DSI
	494	dsi_init_platform_driver,
	495	#endif
	496	#ifdef CONFIG_OMAP2_DSS_DPI
	497	dpi_init_platform_driver,
	498	#endif
	499	#ifdef CONFIG_OMAP2_DSS_SDI
	500	sdi_init_platform_driver,
	501	#endif
	502	#ifdef CONFIG_OMAP2_DSS_RFBI
	503	rfbi_init_platform_driver,
	504	#endif
	505	#ifdef CONFIG_OMAP2_DSS_VENC
	506	venc_init_platform_driver,
	507	#endif
	508	#ifdef CONFIG_OMAP4_DSS_HDMI
	509	hdmi_init_platform_driver,
	510	#endif
	511	};
	512
	513	static void (*dss_output_drv_unreg_funcs[])(void) __exitdata = {
	514	#ifdef CONFIG_OMAP2_DSS_DSI
	515	dsi_uninit_platform_driver,
	516	#endif
	517	#ifdef CONFIG_OMAP2_DSS_DPI
	518	dpi_uninit_platform_driver,
	519	#endif
	520	#ifdef CONFIG_OMAP2_DSS_SDI
	521	sdi_uninit_platform_driver,
	522	#endif
	523	#ifdef CONFIG_OMAP2_DSS_RFBI
	524	rfbi_uninit_platform_driver,
	525	#endif
	526	#ifdef CONFIG_OMAP2_DSS_VENC
	527	venc_uninit_platform_driver,
	528	#endif
	529	#ifdef CONFIG_OMAP4_DSS_HDMI
	530	hdmi_uninit_platform_driver,
	531	#endif
	532	};
	533
	534	static bool dss_output_drv_loaded[ARRAY_SIZE(dss_output_drv_reg_funcs)];
	535
	536	static int __init omap_dss_register_drivers(void)
	537	{
	538	int r;
	539	int i;
	540
	541	r = platform_driver_probe(&omap_dss_driver, omap_dss_probe);
	542	if (r)
	543	return r;
	544
	545	r = dss_init_platform_driver();
	546	if (r) {
	547	DSSERR("Failed to initialize DSS platform driver\n");
	548	goto err_dss;
	549	}
	550
	551	r = dispc_init_platform_driver();
	552	if (r) {
	553	DSSERR("Failed to initialize dispc platform driver\n");
	554	goto err_dispc;
	555	}
	556
	557	/*
	558	* It's ok if the output-driver register fails. It happens, for example,
	559	* when there is no output-device (e.g. SDI for OMAP4).
	560	*/
	561	for (i = 0; i < ARRAY_SIZE(dss_output_drv_reg_funcs); ++i) {
	562	r = dss_output_drv_reg_funcs[i]();
	563	if (r == 0)
	564	dss_output_drv_loaded[i] = true;
	565	}
	566
	567	return 0;
	568
	569	err_dispc:
	570	dss_uninit_platform_driver();
	571	err_dss:
	572	platform_driver_unregister(&omap_dss_driver);
	573
	574	return r;
	575	}
	576
	577	static void __exit omap_dss_unregister_drivers(void)
	578	{
	579	int i;
	580
	581	for (i = 0; i < ARRAY_SIZE(dss_output_drv_unreg_funcs); ++i) {
	582	if (dss_output_drv_loaded[i])
	583	dss_output_drv_unreg_funcs[i]();
	584	}
	585
	586	dispc_uninit_platform_driver();
	587	dss_uninit_platform_driver();
	588
	589	platform_driver_unregister(&omap_dss_driver);
	590	}
	591
	592	#ifdef CONFIG_OMAP2_DSS_MODULE
	593	static void omap_dss_bus_unregister(void)
	594	{
	595	device_unregister(&dss_bus);
	596
	597	bus_unregister(&dss_bus_type);
	598	}
	599
	600	static int __init omap_dss_init(void)
	601	{
	602	int r;
	603
	604	r = omap_dss_bus_register();
	605	if (r)
	606	return r;
	607
	608	r = omap_dss_register_drivers();
	609	if (r) {
	610	omap_dss_bus_unregister();
	611	return r;
	612	}
	613
	614	dss_initialized = true;
	615
	616	return 0;
	617	}
	618
	619	static void __exit omap_dss_exit(void)
	620	{
	621	if (core.vdds_dsi_reg != NULL) {
	622	regulator_put(core.vdds_dsi_reg);
	623	core.vdds_dsi_reg = NULL;
	624	}
	625
	626	if (core.vdds_sdi_reg != NULL) {
	627	regulator_put(core.vdds_sdi_reg);
	628	core.vdds_sdi_reg = NULL;
	629	}
	630
	631	omap_dss_unregister_drivers();
	632
	633	omap_dss_bus_unregister();
	634	}
	635
	636	module_init(omap_dss_init);
	637	module_exit(omap_dss_exit);
	638	#else
	639	static int __init omap_dss_init(void)
	640	{
	641	return omap_dss_bus_register();
	642	}
	643
	644	static int __init omap_dss_init2(void)
	645	{
	646	int r;
	647
	648	r = omap_dss_register_drivers();
	649	if (r)
	650	return r;
	651
	652	dss_initialized = true;
	653
	654	return 0;
	655	}
	656
	657	core_initcall(omap_dss_init);
	658	device_initcall(omap_dss_init2);
	659	#endif
	660
	661	MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
	662	MODULE_DESCRIPTION("OMAP2/3 Display Subsystem");
	663	MODULE_LICENSE("GPL v2");
	664