Merge branch 'dss-devtree-cleanup' (38137c8f) · Commits · e / devices / android_kernel_samsung_universal8895

arch/arm/mach-omap2/display.c

+161 −31

Original line number	Original line	Diff line number	Diff line
	@@ -185,16 +185,128 @@ static int omap_dss_set_min_bus_tput(struct device *dev, unsigned long tput)
	return omap_pm_set_min_bus_tput(dev, OCP_INITIATOR_AGENT, tput);		return omap_pm_set_min_bus_tput(dev, OCP_INITIATOR_AGENT, tput);
	}		}

			static struct platform_device create_dss_pdev(const char pdev_name,
			int pdev_id, const char oh_name, void pdata, int pdata_len,
			struct platform_device *parent)
			{
			struct platform_device *pdev;
			struct omap_device *od;
			struct omap_hwmod *ohs[1];
			struct omap_hwmod *oh;
			int r;

			oh = omap_hwmod_lookup(oh_name);
			if (!oh) {
			pr_err("Could not look up %s\n", oh_name);
			r = -ENODEV;
			goto err;
			}

			pdev = platform_device_alloc(pdev_name, pdev_id);
			if (!pdev) {
			pr_err("Could not create pdev for %s\n", pdev_name);
			r = -ENOMEM;
			goto err;
			}

			if (parent != NULL)
			pdev->dev.parent = &parent->dev;

			if (pdev->id != -1)
			dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
			else
			dev_set_name(&pdev->dev, "%s", pdev->name);

			ohs[0] = oh;
			od = omap_device_alloc(pdev, ohs, 1, NULL, 0);
			if (!od) {
			pr_err("Could not alloc omap_device for %s\n", pdev_name);
			r = -ENOMEM;
			goto err;
			}

			r = platform_device_add_data(pdev, pdata, pdata_len);
			if (r) {
			pr_err("Could not set pdata for %s\n", pdev_name);
			goto err;
			}

			r = omap_device_register(pdev);
			if (r) {
			pr_err("Could not register omap_device for %s\n", pdev_name);
			goto err;
			}

			return pdev;

			err:
			return ERR_PTR(r);
			}

			static struct platform_device create_simple_dss_pdev(const char pdev_name,
			int pdev_id, void *pdata, int pdata_len,
			struct platform_device *parent)
			{
			struct platform_device *pdev;
			int r;

			pdev = platform_device_alloc(pdev_name, pdev_id);
			if (!pdev) {
			pr_err("Could not create pdev for %s\n", pdev_name);
			r = -ENOMEM;
			goto err;
			}

			if (parent != NULL)
			pdev->dev.parent = &parent->dev;

			if (pdev->id != -1)
			dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
			else
			dev_set_name(&pdev->dev, "%s", pdev->name);

			r = platform_device_add_data(pdev, pdata, pdata_len);
			if (r) {
			pr_err("Could not set pdata for %s\n", pdev_name);
			goto err;
			}

			r = omap_device_register(pdev);
			if (r) {
			pr_err("Could not register omap_device for %s\n", pdev_name);
			goto err;
			}

			return pdev;

			err:
			return ERR_PTR(r);
			}

	int __init omap_display_init(struct omap_dss_board_info *board_data)		int __init omap_display_init(struct omap_dss_board_info *board_data)
	{		{
	int r = 0;		int r = 0;
	struct omap_hwmod *oh;
	struct platform_device *pdev;		struct platform_device *pdev;
	int i, oh_count;		int i, oh_count;
	struct omap_display_platform_data pdata;
	const struct omap_dss_hwmod_data *curr_dss_hwmod;		const struct omap_dss_hwmod_data *curr_dss_hwmod;
			struct platform_device *dss_pdev;

			/* create omapdss device */

			board_data->dsi_enable_pads = omap_dsi_enable_pads;
			board_data->dsi_disable_pads = omap_dsi_disable_pads;
			board_data->get_context_loss_count = omap_pm_get_dev_context_loss_count;
			board_data->set_min_bus_tput = omap_dss_set_min_bus_tput;

	memset(&pdata, 0, sizeof(pdata));		omap_display_device.dev.platform_data = board_data;

			r = platform_device_register(&omap_display_device);
			if (r < 0) {
			pr_err("Unable to register omapdss device\n");
			return r;
			}

			/* create devices for dss hwmods */

	if (cpu_is_omap24xx()) {		if (cpu_is_omap24xx()) {
	curr_dss_hwmod = omap2_dss_hwmod_data;		curr_dss_hwmod = omap2_dss_hwmod_data;
	@@ -207,40 +319,58 @@ int __init omap_display_init(struct omap_dss_board_info *board_data)
	oh_count = ARRAY_SIZE(omap4_dss_hwmod_data);		oh_count = ARRAY_SIZE(omap4_dss_hwmod_data);
	}		}

	if (board_data->dsi_enable_pads == NULL)		/*
	board_data->dsi_enable_pads = omap_dsi_enable_pads;		* First create the pdev for dss_core, which is used as a parent device
	if (board_data->dsi_disable_pads == NULL)		* by the other dss pdevs. Note: dss_core has to be the first item in
	board_data->dsi_disable_pads = omap_dsi_disable_pads;		* the hwmod list.
			*/
			dss_pdev = create_dss_pdev(curr_dss_hwmod[0].dev_name,
			curr_dss_hwmod[0].id,
			curr_dss_hwmod[0].oh_name,
			board_data, sizeof(*board_data),
			NULL);

	pdata.board_data = board_data;		if (IS_ERR(dss_pdev)) {
	pdata.board_data->get_context_loss_count =		pr_err("Could not build omap_device for %s\n",
	omap_pm_get_dev_context_loss_count;		curr_dss_hwmod[0].oh_name);
	pdata.board_data->set_min_bus_tput = omap_dss_set_min_bus_tput;

	for (i = 0; i < oh_count; i++) {		return PTR_ERR(dss_pdev);
	oh = omap_hwmod_lookup(curr_dss_hwmod[i].oh_name);		}
	if (!oh) {
	pr_err("Could not look up %s\n",		for (i = 1; i < oh_count; i++) {
			pdev = create_dss_pdev(curr_dss_hwmod[i].dev_name,
			curr_dss_hwmod[i].id,
			curr_dss_hwmod[i].oh_name,
			board_data, sizeof(*board_data),
			dss_pdev);

			if (IS_ERR(pdev)) {
			pr_err("Could not build omap_device for %s\n",
	curr_dss_hwmod[i].oh_name);		curr_dss_hwmod[i].oh_name);
	return -ENODEV;
			return PTR_ERR(pdev);
			}
	}		}

	pdev = omap_device_build(curr_dss_hwmod[i].dev_name,		/* Create devices for DPI and SDI */
	curr_dss_hwmod[i].id, oh, &pdata,
	sizeof(struct omap_display_platform_data),
	NULL, 0, 0);

	if (WARN((IS_ERR(pdev)), "Could not build omap_device for %s\n",		pdev = create_simple_dss_pdev("omapdss_dpi", -1,
	curr_dss_hwmod[i].oh_name))		board_data, sizeof(*board_data), dss_pdev);
	return -ENODEV;		if (IS_ERR(pdev)) {
			pr_err("Could not build platform_device for omapdss_dpi\n");
			return PTR_ERR(pdev);
	}		}
	omap_display_device.dev.platform_data = board_data;

	r = platform_device_register(&omap_display_device);		if (cpu_is_omap34xx()) {
	if (r < 0)		pdev = create_simple_dss_pdev("omapdss_sdi", -1,
	printk(KERN_ERR "Unable to register OMAP-Display device\n");		board_data, sizeof(*board_data), dss_pdev);
			if (IS_ERR(pdev)) {
			pr_err("Could not build platform_device for omapdss_sdi\n");
			return PTR_ERR(pdev);
			}
			}

	return r;		return 0;
	}		}

	static void dispc_disable_outputs(void)		static void dispc_disable_outputs(void)

drivers/video/omap2/displays/panel-tfp410.c

+40 −36

Original line number	Original line	Diff line number	Diff line
	@@ -47,13 +47,9 @@ struct panel_drv_data {
	struct mutex lock;		struct mutex lock;

	int pd_gpio;		int pd_gpio;
	};

	static inline struct tfp410_platform_data		struct i2c_adapter *i2c_adapter;
	get_pdata(const struct omap_dss_device dssdev)		};
	{
	return dssdev->data;
	}

	static int tfp410_power_on(struct omap_dss_device *dssdev)		static int tfp410_power_on(struct omap_dss_device *dssdev)
	{		{
	@@ -68,7 +64,7 @@ static int tfp410_power_on(struct omap_dss_device *dssdev)
	goto err0;		goto err0;

	if (gpio_is_valid(ddata->pd_gpio))		if (gpio_is_valid(ddata->pd_gpio))
	gpio_set_value(ddata->pd_gpio, 1);		gpio_set_value_cansleep(ddata->pd_gpio, 1);

	return 0;		return 0;
	err0:		err0:
	@@ -83,18 +79,18 @@ static void tfp410_power_off(struct omap_dss_device *dssdev)
	return;		return;

	if (gpio_is_valid(ddata->pd_gpio))		if (gpio_is_valid(ddata->pd_gpio))
	gpio_set_value(ddata->pd_gpio, 0);		gpio_set_value_cansleep(ddata->pd_gpio, 0);

	omapdss_dpi_display_disable(dssdev);		omapdss_dpi_display_disable(dssdev);
	}		}

	static int tfp410_probe(struct omap_dss_device *dssdev)		static int tfp410_probe(struct omap_dss_device *dssdev)
	{		{
	struct tfp410_platform_data *pdata = get_pdata(dssdev);
	struct panel_drv_data *ddata;		struct panel_drv_data *ddata;
	int r;		int r;
			int i2c_bus_num;

	ddata = kzalloc(sizeof(*ddata), GFP_KERNEL);		ddata = devm_kzalloc(&dssdev->dev, sizeof(*ddata), GFP_KERNEL);
	if (!ddata)		if (!ddata)
	return -ENOMEM;		return -ENOMEM;

	@@ -104,10 +100,15 @@ static int tfp410_probe(struct omap_dss_device *dssdev)
	ddata->dssdev = dssdev;		ddata->dssdev = dssdev;
	mutex_init(&ddata->lock);		mutex_init(&ddata->lock);

	if (pdata)		if (dssdev->data) {
			struct tfp410_platform_data *pdata = dssdev->data;

	ddata->pd_gpio = pdata->power_down_gpio;		ddata->pd_gpio = pdata->power_down_gpio;
	else		i2c_bus_num = pdata->i2c_bus_num;
			} else {
	ddata->pd_gpio = -1;		ddata->pd_gpio = -1;
			i2c_bus_num = -1;
			}

	if (gpio_is_valid(ddata->pd_gpio)) {		if (gpio_is_valid(ddata->pd_gpio)) {
	r = gpio_request_one(ddata->pd_gpio, GPIOF_OUT_INIT_LOW,		r = gpio_request_one(ddata->pd_gpio, GPIOF_OUT_INIT_LOW,
	@@ -115,13 +116,31 @@ static int tfp410_probe(struct omap_dss_device *dssdev)
	if (r) {		if (r) {
	dev_err(&dssdev->dev, "Failed to request PD GPIO %d\n",		dev_err(&dssdev->dev, "Failed to request PD GPIO %d\n",
	ddata->pd_gpio);		ddata->pd_gpio);
	ddata->pd_gpio = -1;		return r;
			}
			}

			if (i2c_bus_num != -1) {
			struct i2c_adapter *adapter;

			adapter = i2c_get_adapter(i2c_bus_num);
			if (!adapter) {
			dev_err(&dssdev->dev, "Failed to get I2C adapter, bus %d\n",
			i2c_bus_num);
			r = -EINVAL;
			goto err_i2c;
	}		}

			ddata->i2c_adapter = adapter;
	}		}

	dev_set_drvdata(&dssdev->dev, ddata);		dev_set_drvdata(&dssdev->dev, ddata);

	return 0;		return 0;
			err_i2c:
			if (gpio_is_valid(ddata->pd_gpio))
			gpio_free(ddata->pd_gpio);
			return r;
	}		}

	static void __exit tfp410_remove(struct omap_dss_device *dssdev)		static void __exit tfp410_remove(struct omap_dss_device *dssdev)
	@@ -130,14 +149,15 @@ static void __exit tfp410_remove(struct omap_dss_device *dssdev)

	mutex_lock(&ddata->lock);		mutex_lock(&ddata->lock);

			if (ddata->i2c_adapter)
			i2c_put_adapter(ddata->i2c_adapter);

	if (gpio_is_valid(ddata->pd_gpio))		if (gpio_is_valid(ddata->pd_gpio))
	gpio_free(ddata->pd_gpio);		gpio_free(ddata->pd_gpio);

	dev_set_drvdata(&dssdev->dev, NULL);		dev_set_drvdata(&dssdev->dev, NULL);

	mutex_unlock(&ddata->lock);		mutex_unlock(&ddata->lock);

	kfree(ddata);
	}		}

	static int tfp410_enable(struct omap_dss_device *dssdev)		static int tfp410_enable(struct omap_dss_device *dssdev)
	@@ -269,27 +289,17 @@ static int tfp410_read_edid(struct omap_dss_device *dssdev,
	u8 *edid, int len)		u8 *edid, int len)
	{		{
	struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);		struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
	struct tfp410_platform_data *pdata = get_pdata(dssdev);
	struct i2c_adapter *adapter;
	int r, l, bytes_read;		int r, l, bytes_read;

	mutex_lock(&ddata->lock);		mutex_lock(&ddata->lock);

	if (pdata->i2c_bus_num == 0) {		if (!ddata->i2c_adapter) {
	r = -ENODEV;		r = -ENODEV;
	goto err;		goto err;
	}		}

	adapter = i2c_get_adapter(pdata->i2c_bus_num);
	if (!adapter) {
	dev_err(&dssdev->dev, "Failed to get I2C adapter, bus %d\n",
	pdata->i2c_bus_num);
	r = -EINVAL;
	goto err;
	}

	l = min(EDID_LENGTH, len);		l = min(EDID_LENGTH, len);
	r = tfp410_ddc_read(adapter, edid, l, 0);		r = tfp410_ddc_read(ddata->i2c_adapter, edid, l, 0);
	if (r)		if (r)
	goto err;		goto err;

	@@ -299,7 +309,7 @@ static int tfp410_read_edid(struct omap_dss_device *dssdev,
	if (len > EDID_LENGTH && edid[0x7e] > 0) {		if (len > EDID_LENGTH && edid[0x7e] > 0) {
	l = min(EDID_LENGTH, len - EDID_LENGTH);		l = min(EDID_LENGTH, len - EDID_LENGTH);

	r = tfp410_ddc_read(adapter, edid + EDID_LENGTH,		r = tfp410_ddc_read(ddata->i2c_adapter, edid + EDID_LENGTH,
	l, EDID_LENGTH);		l, EDID_LENGTH);
	if (r)		if (r)
	goto err;		goto err;
	@@ -319,21 +329,15 @@ err:
	static bool tfp410_detect(struct omap_dss_device *dssdev)		static bool tfp410_detect(struct omap_dss_device *dssdev)
	{		{
	struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);		struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
	struct tfp410_platform_data *pdata = get_pdata(dssdev);
	struct i2c_adapter *adapter;
	unsigned char out;		unsigned char out;
	int r;		int r;

	mutex_lock(&ddata->lock);		mutex_lock(&ddata->lock);

	if (pdata->i2c_bus_num == 0)		if (!ddata->i2c_adapter)
	goto out;

	adapter = i2c_get_adapter(pdata->i2c_bus_num);
	if (!adapter)
	goto out;		goto out;

	r = tfp410_ddc_read(adapter, &out, 1, 0);		r = tfp410_ddc_read(ddata->i2c_adapter, &out, 1, 0);

	mutex_unlock(&ddata->lock);		mutex_unlock(&ddata->lock);

drivers/video/omap2/dss/core.c

+140 −103

Original line number	Original line	Diff line number	Diff line
	@@ -43,6 +43,8 @@ static struct {

	struct regulator *vdds_dsi_reg;		struct regulator *vdds_dsi_reg;
	struct regulator *vdds_sdi_reg;		struct regulator *vdds_sdi_reg;

			const char *default_display_name;
	} core;		} core;

	static char *def_disp_name;		static char *def_disp_name;
	@@ -54,9 +56,6 @@ bool dss_debug;
	module_param_named(debug, dss_debug, bool, 0644);		module_param_named(debug, dss_debug, bool, 0644);
	#endif		#endif

	static int omap_dss_register_device(struct omap_dss_device *);
	static void omap_dss_unregister_device(struct omap_dss_device *);

	/* REGULATORS */		/* REGULATORS */

	struct regulator *dss_get_vdds_dsi(void)		struct regulator *dss_get_vdds_dsi(void)
	@@ -87,6 +86,41 @@ struct regulator *dss_get_vdds_sdi(void)
	return reg;		return reg;
	}		}

			int dss_get_ctx_loss_count(struct device *dev)
			{
			struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;
			int cnt;

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

			cnt = board_data->get_context_loss_count(dev);

			WARN_ONCE(cnt < 0, "get_context_loss_count failed: %d\n", cnt);

			return cnt;
			}

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

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

	int dss_set_min_bus_tput(struct device *dev, unsigned long tput)		int dss_set_min_bus_tput(struct device *dev, unsigned long tput)
	{		{
	struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;		struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
	@@ -131,34 +165,6 @@ static int dss_initialize_debugfs(void)
	debugfs_create_file("clk", S_IRUGO, dss_debugfs_dir,		debugfs_create_file("clk", S_IRUGO, dss_debugfs_dir,
	&dss_debug_dump_clocks, &dss_debug_fops);		&dss_debug_dump_clocks, &dss_debug_fops);

	#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
	debugfs_create_file("dispc_irq", S_IRUGO, dss_debugfs_dir,
	&dispc_dump_irqs, &dss_debug_fops);
	#endif

	#if defined(CONFIG_OMAP2_DSS_DSI) && defined(CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS)
	dsi_create_debugfs_files_irq(dss_debugfs_dir, &dss_debug_fops);
	#endif

	debugfs_create_file("dss", S_IRUGO, dss_debugfs_dir,
	&dss_dump_regs, &dss_debug_fops);
	debugfs_create_file("dispc", S_IRUGO, dss_debugfs_dir,
	&dispc_dump_regs, &dss_debug_fops);
	#ifdef CONFIG_OMAP2_DSS_RFBI
	debugfs_create_file("rfbi", S_IRUGO, dss_debugfs_dir,
	&rfbi_dump_regs, &dss_debug_fops);
	#endif
	#ifdef CONFIG_OMAP2_DSS_DSI
	dsi_create_debugfs_files_reg(dss_debugfs_dir, &dss_debug_fops);
	#endif
	#ifdef CONFIG_OMAP2_DSS_VENC
	debugfs_create_file("venc", S_IRUGO, dss_debugfs_dir,
	&venc_dump_regs, &dss_debug_fops);
	#endif
	#ifdef CONFIG_OMAP4_DSS_HDMI
	debugfs_create_file("hdmi", S_IRUGO, dss_debugfs_dir,
	&hdmi_dump_regs, &dss_debug_fops);
	#endif
	return 0;		return 0;
	}		}

	@@ -167,6 +173,19 @@ static void dss_uninitialize_debugfs(void)
	if (dss_debugfs_dir)		if (dss_debugfs_dir)
	debugfs_remove_recursive(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);

			if (IS_ERR(d))
			return PTR_ERR(d);

			return 0;
			}
	#else /* CONFIG_DEBUG_FS && CONFIG_OMAP2_DSS_DEBUG_SUPPORT */		#else /* CONFIG_DEBUG_FS && CONFIG_OMAP2_DSS_DEBUG_SUPPORT */
	static inline int dss_initialize_debugfs(void)		static inline int dss_initialize_debugfs(void)
	{		{
	@@ -175,14 +194,18 @@ static inline int dss_initialize_debugfs(void)
	static inline void dss_uninitialize_debugfs(void)		static inline void dss_uninitialize_debugfs(void)
	{		{
	}		}
			static inline int dss_debugfs_create_file(const char *name,
			void (write)(struct seq_file ))
			{
			return 0;
			}
	#endif /* CONFIG_DEBUG_FS && CONFIG_OMAP2_DSS_DEBUG_SUPPORT */		#endif /* CONFIG_DEBUG_FS && CONFIG_OMAP2_DSS_DEBUG_SUPPORT */

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

	core.pdev = pdev;		core.pdev = pdev;

	@@ -197,28 +220,13 @@ static int omap_dss_probe(struct platform_device *pdev)
	if (r)		if (r)
	goto err_debugfs;		goto err_debugfs;

	for (i = 0; i < pdata->num_devices; ++i) {		if (def_disp_name)
	struct omap_dss_device *dssdev = pdata->devices[i];		core.default_display_name = def_disp_name;
			else if (pdata->default_device)
	r = omap_dss_register_device(dssdev);		core.default_display_name = pdata->default_device->name;
	if (r) {
	DSSERR("device %d %s register failed %d\n", i,
	dssdev->name ?: "unnamed", r);

	while (--i >= 0)
	omap_dss_unregister_device(pdata->devices[i]);

	goto err_register;
	}

	if (def_disp_name && strcmp(def_disp_name, dssdev->name) == 0)
	pdata->default_device = dssdev;
	}

	return 0;		return 0;

	err_register:
	dss_uninitialize_debugfs();
	err_debugfs:		err_debugfs:

	return r;		return r;
	@@ -226,17 +234,11 @@ err_debugfs:

	static int omap_dss_remove(struct platform_device *pdev)		static int omap_dss_remove(struct platform_device *pdev)
	{		{
	struct omap_dss_board_info *pdata = pdev->dev.platform_data;
	int i;

	dss_uninitialize_debugfs();		dss_uninitialize_debugfs();

	dss_uninit_overlays(pdev);		dss_uninit_overlays(pdev);
	dss_uninit_overlay_managers(pdev);		dss_uninit_overlay_managers(pdev);

	for (i = 0; i < pdata->num_devices; ++i)
	omap_dss_unregister_device(pdata->devices[i]);

	return 0;		return 0;
	}		}

	@@ -261,7 +263,6 @@ static int omap_dss_resume(struct platform_device *pdev)
	}		}

	static struct platform_driver omap_dss_driver = {		static struct platform_driver omap_dss_driver = {
	.probe = omap_dss_probe,
	.remove = omap_dss_remove,		.remove = omap_dss_remove,
	.shutdown = omap_dss_shutdown,		.shutdown = omap_dss_shutdown,
	.suspend = omap_dss_suspend,		.suspend = omap_dss_suspend,
	@@ -336,7 +337,6 @@ static int dss_driver_probe(struct device *dev)
	int r;		int r;
	struct omap_dss_driver *dssdrv = to_dss_driver(dev->driver);		struct omap_dss_driver *dssdrv = to_dss_driver(dev->driver);
	struct omap_dss_device *dssdev = to_dss_device(dev);		struct omap_dss_device *dssdev = to_dss_device(dev);
	struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
	bool force;		bool force;

	DSSDBG("driver_probe: dev %s/%s, drv %s\n",		DSSDBG("driver_probe: dev %s/%s, drv %s\n",
	@@ -345,7 +345,8 @@ static int dss_driver_probe(struct device *dev)

	dss_init_device(core.pdev, dssdev);		dss_init_device(core.pdev, dssdev);

	force = pdata->default_device == dssdev;		force = core.default_display_name &&
			strcmp(core.default_display_name, dssdev->name) == 0;
	dss_recheck_connections(dssdev, force);		dss_recheck_connections(dssdev, force);

	r = dssdrv->probe(dssdev);		r = dssdrv->probe(dssdev);
	@@ -439,27 +440,38 @@ static void omap_dss_dev_release(struct device *dev)
	reset_device(dev, 0);		reset_device(dev, 0);
	}		}

	static int omap_dss_register_device(struct omap_dss_device *dssdev)		int omap_dss_register_device(struct omap_dss_device *dssdev,
			struct device *parent, int disp_num)
	{		{
	static int dev_num;

	WARN_ON(!dssdev->driver_name);		WARN_ON(!dssdev->driver_name);

	reset_device(&dssdev->dev, 1);		reset_device(&dssdev->dev, 1);
	dssdev->dev.bus = &dss_bus_type;		dssdev->dev.bus = &dss_bus_type;
	dssdev->dev.parent = &dss_bus;		dssdev->dev.parent = parent;
	dssdev->dev.release = omap_dss_dev_release;		dssdev->dev.release = omap_dss_dev_release;
	dev_set_name(&dssdev->dev, "display%d", dev_num++);		dev_set_name(&dssdev->dev, "display%d", disp_num);
	return device_register(&dssdev->dev);		return device_register(&dssdev->dev);
	}		}

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

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

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

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

	@@ -481,12 +493,56 @@ static int omap_dss_bus_register(void)
	}		}

	/* INIT */		/* INIT */
			static int (*dss_output_drv_reg_funcs[])(void) __initdata = {
			#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_OMAP2_DSS_DSI
			dsi_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_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_OMAP2_DSS_DSI
			dsi_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)		static int __init omap_dss_register_drivers(void)
	{		{
	int r;		int r;
			int i;

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

	@@ -502,40 +558,18 @@ static int __init omap_dss_register_drivers(void)
	goto err_dispc;		goto err_dispc;
	}		}

	r = rfbi_init_platform_driver();		/*
	if (r) {		* It's ok if the output-driver register fails. It happens, for example,
	DSSERR("Failed to initialize rfbi platform driver\n");		* when there is no output-device (e.g. SDI for OMAP4).
	goto err_rfbi;		*/
	}		for (i = 0; i < ARRAY_SIZE(dss_output_drv_reg_funcs); ++i) {
			r = dss_output_drv_reg_funcs[i]();
	r = venc_init_platform_driver();		if (r == 0)
	if (r) {		dss_output_drv_loaded[i] = true;
	DSSERR("Failed to initialize venc platform driver\n");
	goto err_venc;
	}

	r = dsi_init_platform_driver();
	if (r) {
	DSSERR("Failed to initialize DSI platform driver\n");
	goto err_dsi;
	}

	r = hdmi_init_platform_driver();
	if (r) {
	DSSERR("Failed to initialize hdmi\n");
	goto err_hdmi;
	}		}

	return 0;		return 0;

	err_hdmi:
	dsi_uninit_platform_driver();
	err_dsi:
	venc_uninit_platform_driver();
	err_venc:
	rfbi_uninit_platform_driver();
	err_rfbi:
	dispc_uninit_platform_driver();
	err_dispc:		err_dispc:
	dss_uninit_platform_driver();		dss_uninit_platform_driver();
	err_dss:		err_dss:
	@@ -546,10 +580,13 @@ err_dss:

	static void __exit omap_dss_unregister_drivers(void)		static void __exit omap_dss_unregister_drivers(void)
	{		{
	hdmi_uninit_platform_driver();		int i;
	dsi_uninit_platform_driver();
	venc_uninit_platform_driver();		for (i = 0; i < ARRAY_SIZE(dss_output_drv_unreg_funcs); ++i) {
	rfbi_uninit_platform_driver();		if (dss_output_drv_loaded[i])
			dss_output_drv_unreg_funcs[i]();
			}

	dispc_uninit_platform_driver();		dispc_uninit_platform_driver();
	dss_uninit_platform_driver();		dss_uninit_platform_driver();

drivers/video/omap2/dss/dispc.c

+15 −35

Original line number	Original line	Diff line number	Diff line
	@@ -131,23 +131,6 @@ static inline u32 dispc_read_reg(const u16 idx)
	return __raw_readl(dispc.base + idx);		return __raw_readl(dispc.base + idx);
	}		}

	static int dispc_get_ctx_loss_count(void)
	{
	struct device *dev = &dispc.pdev->dev;
	struct omap_display_platform_data *pdata = dev->platform_data;
	struct omap_dss_board_info *board_data = pdata->board_data;
	int cnt;

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

	cnt = board_data->get_context_loss_count(dev);

	WARN_ONCE(cnt < 0, "get_context_loss_count failed: %d\n", cnt);

	return cnt;
	}

	#define SR(reg) \		#define SR(reg) \
	dispc.ctx[DISPC_##reg / sizeof(u32)] = dispc_read_reg(DISPC_##reg)		dispc.ctx[DISPC_##reg / sizeof(u32)] = dispc_read_reg(DISPC_##reg)
	#define RR(reg) \		#define RR(reg) \
	@@ -251,7 +234,7 @@ static void dispc_save_context(void)
	if (dss_has_feature(FEAT_CORE_CLK_DIV))		if (dss_has_feature(FEAT_CORE_CLK_DIV))
	SR(DIVISOR);		SR(DIVISOR);

	dispc.ctx_loss_cnt = dispc_get_ctx_loss_count();		dispc.ctx_loss_cnt = dss_get_ctx_loss_count(&dispc.pdev->dev);
	dispc.ctx_valid = true;		dispc.ctx_valid = true;

	DSSDBG("context saved, ctx_loss_count %d\n", dispc.ctx_loss_cnt);		DSSDBG("context saved, ctx_loss_count %d\n", dispc.ctx_loss_cnt);
	@@ -266,7 +249,7 @@ static void dispc_restore_context(void)
	if (!dispc.ctx_valid)		if (!dispc.ctx_valid)
	return;		return;

	ctx = dispc_get_ctx_loss_count();		ctx = dss_get_ctx_loss_count(&dispc.pdev->dev);

	if (ctx >= 0 && ctx == dispc.ctx_loss_cnt)		if (ctx >= 0 && ctx == dispc.ctx_loss_cnt)
	return;		return;
	@@ -2778,7 +2761,7 @@ void dispc_dump_irqs(struct seq_file *s)
	}		}
	#endif		#endif

	void dispc_dump_regs(struct seq_file *s)		static void dispc_dump_regs(struct seq_file *s)
	{		{
	int i, j;		int i, j;
	const char *mgr_names[] = {		const char *mgr_names[] = {
	@@ -3499,7 +3482,7 @@ static void _omap_dispc_initial_config(void)
	}		}

	/* DISPC HW IP initialisation */		/* DISPC HW IP initialisation */
	static int omap_dispchw_probe(struct platform_device *pdev)		static int __init omap_dispchw_probe(struct platform_device *pdev)
	{		{
	u32 rev;		u32 rev;
	int r = 0;		int r = 0;
	@@ -3568,6 +3551,11 @@ static int omap_dispchw_probe(struct platform_device *pdev)

	dispc_runtime_put();		dispc_runtime_put();

			dss_debugfs_create_file("dispc", dispc_dump_regs);

			#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
			dss_debugfs_create_file("dispc_irq", dispc_dump_irqs);
			#endif
	return 0;		return 0;

	err_runtime_get:		err_runtime_get:
	@@ -3576,7 +3564,7 @@ err_runtime_get:
	return r;		return r;
	}		}

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

	@@ -3588,19 +3576,12 @@ static int omap_dispchw_remove(struct platform_device *pdev)
	static int dispc_runtime_suspend(struct device *dev)		static int dispc_runtime_suspend(struct device *dev)
	{		{
	dispc_save_context();		dispc_save_context();
	dss_runtime_put();

	return 0;		return 0;
	}		}

	static int dispc_runtime_resume(struct device *dev)		static int dispc_runtime_resume(struct device *dev)
	{		{
	int r;

	r = dss_runtime_get();
	if (r < 0)
	return r;

	dispc_restore_context();		dispc_restore_context();

	return 0;		return 0;
	@@ -3612,8 +3593,7 @@ static const struct dev_pm_ops dispc_pm_ops = {
	};		};

	static struct platform_driver omap_dispchw_driver = {		static struct platform_driver omap_dispchw_driver = {
	.probe = omap_dispchw_probe,		.remove = __exit_p(omap_dispchw_remove),
	.remove = omap_dispchw_remove,
	.driver = {		.driver = {
	.name = "omapdss_dispc",		.name = "omapdss_dispc",
	.owner = THIS_MODULE,		.owner = THIS_MODULE,
	@@ -3621,12 +3601,12 @@ static struct platform_driver omap_dispchw_driver = {
	},		},
	};		};

	int dispc_init_platform_driver(void)		int __init dispc_init_platform_driver(void)
	{		{
	return platform_driver_register(&omap_dispchw_driver);		return platform_driver_probe(&omap_dispchw_driver, omap_dispchw_probe);
	}		}

	void dispc_uninit_platform_driver(void)		void __exit dispc_uninit_platform_driver(void)
	{		{
	return platform_driver_unregister(&omap_dispchw_driver);		platform_driver_unregister(&omap_dispchw_driver);
	}		}

drivers/video/omap2/dss/display.c

+0 −40

Original line number	Original line	Diff line number	Diff line
	@@ -359,46 +359,6 @@ void dss_init_device(struct platform_device *pdev,
	int i;		int i;
	int r;		int r;

	switch (dssdev->type) {
	#ifdef CONFIG_OMAP2_DSS_DPI
	case OMAP_DISPLAY_TYPE_DPI:
	r = dpi_init_display(dssdev);
	break;
	#endif
	#ifdef CONFIG_OMAP2_DSS_RFBI
	case OMAP_DISPLAY_TYPE_DBI:
	r = rfbi_init_display(dssdev);
	break;
	#endif
	#ifdef CONFIG_OMAP2_DSS_VENC
	case OMAP_DISPLAY_TYPE_VENC:
	r = venc_init_display(dssdev);
	break;
	#endif
	#ifdef CONFIG_OMAP2_DSS_SDI
	case OMAP_DISPLAY_TYPE_SDI:
	r = sdi_init_display(dssdev);
	break;
	#endif
	#ifdef CONFIG_OMAP2_DSS_DSI
	case OMAP_DISPLAY_TYPE_DSI:
	r = dsi_init_display(dssdev);
	break;
	#endif
	case OMAP_DISPLAY_TYPE_HDMI:
	r = hdmi_init_display(dssdev);
	break;
	default:
	DSSERR("Support for display '%s' not compiled in.\n",
	dssdev->name);
	return;
	}

	if (r) {
	DSSERR("failed to init display %s\n", dssdev->name);
	return;
	}

	/* create device sysfs files */		/* create device sysfs files */
	i = 0;		i = 0;
	while ((attr = display_sysfs_attrs[i++]) != NULL) {		while ((attr = display_sysfs_attrs[i++]) != NULL) {