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

Commit f76ee892 authored by Tomi Valkeinen's avatar Tomi Valkeinen
Browse files

omapfb: copy omapdss & displays for omapfb 



This patch makes a copy of the omapdss driver and the omap panel &
encoder drivers for omapfb. The purpose is to separate omapdrm and
omapfb drivers from each other.

Note that this patch only does a direct copy of the files without any
other modifications. The files are not yet used.

The original files are in:

drivers/video/fbdev/omap2/dss/
drivers/video/fbdev/omap2/displays-new/

Here's a more detailed explanation about this and the following patches,
from the introduction mail of the patch series:

A short background on the current status. We have the following
entities:

* omapdss, located in drivers/video/fbdev/omap2/dss/. This is a driver for the
  display subsystem IPs used on OMAP (and related) SoCs. It offers only a
  kernel internal API, and does not implement anything for fbdev or drm.

* omapdss panels and encoders, located in
  drivers/video/fbdev/omap2/displays-new/. These are panel and external encoder
  drivers, which use APIs offered by omapdss driver. These also don't implement
  anything for fbdev or drm.

* omapdrm, located in drivers/gpu/drm/omapdrm/. This is a drm driver, which
  uses omapdss and the panel/encoder drivers to operate the hardware.

* omapfb, located in drivers/video/fbdev/omap2/omapfb/. This is an fbdev
  driver, which uses omapdss and the panel/encoder drivers to operate the
  hardware.

* omap_vout, located in drivers/media/platform/omap/. This is a v4l2 driver,
  which uses omapdss and omapfb to implement a v4l2 API for the video overlays.

So, on the top level, we have either omapdrm, or omapfb+omap_vout. Both of
those use the same low level drivers. Without going to the historical details
why the architecture is like that, I think it's finally time to change that.

The situation with omapfb+omap_vout is that it still works, but no new features
have been added for a long time, and I want to keep it working as it's still
being used.  At some point in the future I'd like to remove omapfb and
omap_vout altogether.

Omapdrm, on the other hand, is being actively developed. Sharing the low level
parts with omapfb makes that development more difficult than it should be. It
also "hides" half of the development, as everything happening in the low level
parts resides under fbdev directory, not in the drm directory.

I've been wanting to clean this up for a long time, but I haven't figured out a
very good way to do it. I still haven't, but here's the best way I have come up
with.

This series makes a full copy of the low level parts, omapdss and panel/encoder
drivers. Both omapfb+omap_vout and omapdrm will have their own versions. The
copy omapfb+omap_vout get is a new copy, and the copy that omapdrm gets is just
the current files moved. This way git will associate the omapdrm version with
the old files.

The omapfb+omap_vout versions won't be touched unless there are some big issues
there.

The omapdrm versions can be refactored and cleaned up, as the omapfb support
code is no longer needed. We can perhaps also merge omapdss and omapdrm into
the same kernel module.

This series only does the copy, and the absolutely necessary parts. No further
cleanups are done yet.

Signed-off-by: default avatarTomi Valkeinen <tomi.valkeinen@ti.com>
Acked-by: default avatarDave Airlie <airlied@gmail.com>
Acked-by: default avatarRob Clark <robdclark@gmail.com>
parent 1c6aac92

drivers/video/fbdev/omap2/omapfb/displays/Kconfig

0 → 100644
+86 −0
Original line number Diff line number Diff line 
menu "OMAP Display Device Drivers (new device model)"

        depends on OMAP2_DSS



config DISPLAY_ENCODER_OPA362

	tristate "OPA362 external analog amplifier"

	help

	  Driver for OPA362 external analog TV amplifier controlled

	  through a GPIO.



config DISPLAY_ENCODER_TFP410

        tristate "TFP410 DPI to DVI Encoder"

	help

	  Driver for TFP410 DPI to DVI encoder.



config DISPLAY_ENCODER_TPD12S015

        tristate "TPD12S015 HDMI ESD protection and level shifter"

	help

	  Driver for TPD12S015, which offers HDMI ESD protection and level

	  shifting.



config DISPLAY_CONNECTOR_DVI

        tristate "DVI Connector"

	depends on I2C

	help

	  Driver for a generic DVI connector.



config DISPLAY_CONNECTOR_HDMI

        tristate "HDMI Connector"

	help

	  Driver for a generic HDMI connector.



config DISPLAY_CONNECTOR_ANALOG_TV

        tristate "Analog TV Connector"

	help

	  Driver for a generic analog TV connector.



config DISPLAY_PANEL_DPI

	tristate "Generic DPI panel"

	help

	  Driver for generic DPI panels.



config DISPLAY_PANEL_DSI_CM

	tristate "Generic DSI Command Mode Panel"

	depends on BACKLIGHT_CLASS_DEVICE

	help

	  Driver for generic DSI command mode panels.



config DISPLAY_PANEL_SONY_ACX565AKM

	tristate "ACX565AKM Panel"

	depends on SPI && BACKLIGHT_CLASS_DEVICE

	help

	  This is the LCD panel used on Nokia N900



config DISPLAY_PANEL_LGPHILIPS_LB035Q02

	tristate "LG.Philips LB035Q02 LCD Panel"

	depends on SPI

	help

	  LCD Panel used on the Gumstix Overo Palo35



config DISPLAY_PANEL_SHARP_LS037V7DW01

        tristate "Sharp LS037V7DW01 LCD Panel"

        depends on BACKLIGHT_CLASS_DEVICE

        help

          LCD Panel used in TI's SDP3430 and EVM boards



config DISPLAY_PANEL_TPO_TD028TTEC1

        tristate "TPO TD028TTEC1 LCD Panel"

        depends on SPI

        help

          LCD panel used in Openmoko.



config DISPLAY_PANEL_TPO_TD043MTEA1

        tristate "TPO TD043MTEA1 LCD Panel"

        depends on SPI

        help

          LCD Panel used in OMAP3 Pandora



config DISPLAY_PANEL_NEC_NL8048HL11

	tristate "NEC NL8048HL11 Panel"

	depends on SPI

	depends on BACKLIGHT_CLASS_DEVICE

	help

		This NEC NL8048HL11 panel is TFT LCD used in the

		Zoom2/3/3630 sdp boards.



endmenu

drivers/video/fbdev/omap2/omapfb/displays/Makefile

0 → 100644
+14 −0
Original line number Diff line number Diff line 
obj-$(CONFIG_DISPLAY_ENCODER_OPA362) += encoder-opa362.o

obj-$(CONFIG_DISPLAY_ENCODER_TFP410) += encoder-tfp410.o

obj-$(CONFIG_DISPLAY_ENCODER_TPD12S015) += encoder-tpd12s015.o

obj-$(CONFIG_DISPLAY_CONNECTOR_DVI) += connector-dvi.o

obj-$(CONFIG_DISPLAY_CONNECTOR_HDMI) += connector-hdmi.o

obj-$(CONFIG_DISPLAY_CONNECTOR_ANALOG_TV) += connector-analog-tv.o

obj-$(CONFIG_DISPLAY_PANEL_DPI) += panel-dpi.o

obj-$(CONFIG_DISPLAY_PANEL_DSI_CM) += panel-dsi-cm.o

obj-$(CONFIG_DISPLAY_PANEL_SONY_ACX565AKM) += panel-sony-acx565akm.o

obj-$(CONFIG_DISPLAY_PANEL_LGPHILIPS_LB035Q02) += panel-lgphilips-lb035q02.o

obj-$(CONFIG_DISPLAY_PANEL_SHARP_LS037V7DW01) += panel-sharp-ls037v7dw01.o

obj-$(CONFIG_DISPLAY_PANEL_TPO_TD028TTEC1) += panel-tpo-td028ttec1.o

obj-$(CONFIG_DISPLAY_PANEL_TPO_TD043MTEA1) += panel-tpo-td043mtea1.o

obj-$(CONFIG_DISPLAY_PANEL_NEC_NL8048HL11) += panel-nec-nl8048hl11.o

drivers/video/fbdev/omap2/omapfb/displays/connector-analog-tv.c

0 → 100644
+320 −0
Original line number Diff line number Diff line 
/*

 * Analog TV Connector driver

 *

 * Copyright (C) 2013 Texas Instruments

 * Author: Tomi Valkeinen <tomi.valkeinen@ti.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/slab.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/of.h>



#include <video/omapdss.h>

#include <video/omap-panel-data.h>



struct panel_drv_data {

	struct omap_dss_device dssdev;

	struct omap_dss_device *in;



	struct device *dev;



	struct omap_video_timings timings;



	enum omap_dss_venc_type connector_type;

	bool invert_polarity;

};



static const struct omap_video_timings tvc_pal_timings = {

	.x_res		= 720,

	.y_res		= 574,

	.pixelclock	= 13500000,

	.hsw		= 64,

	.hfp		= 12,

	.hbp		= 68,

	.vsw		= 5,

	.vfp		= 5,

	.vbp		= 41,



	.interlace	= true,

};



static const struct of_device_id tvc_of_match[];



struct tvc_of_data {

	enum omap_dss_venc_type connector_type;

};



#define to_panel_data(x) container_of(x, struct panel_drv_data, dssdev)



static int tvc_connect(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;

	int r;



	dev_dbg(ddata->dev, "connect\n");



	if (omapdss_device_is_connected(dssdev))

		return 0;



	r = in->ops.atv->connect(in, dssdev);

	if (r)

		return r;



	return 0;

}



static void tvc_disconnect(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	dev_dbg(ddata->dev, "disconnect\n");



	if (!omapdss_device_is_connected(dssdev))

		return;



	in->ops.atv->disconnect(in, dssdev);

}



static int tvc_enable(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;

	int r;



	dev_dbg(ddata->dev, "enable\n");



	if (!omapdss_device_is_connected(dssdev))

		return -ENODEV;



	if (omapdss_device_is_enabled(dssdev))

		return 0;



	in->ops.atv->set_timings(in, &ddata->timings);



	if (!ddata->dev->of_node) {

		in->ops.atv->set_type(in, ddata->connector_type);



		in->ops.atv->invert_vid_out_polarity(in,

			ddata->invert_polarity);

	}



	r = in->ops.atv->enable(in);

	if (r)

		return r;



	dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;



	return r;

}



static void tvc_disable(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	dev_dbg(ddata->dev, "disable\n");



	if (!omapdss_device_is_enabled(dssdev))

		return;



	in->ops.atv->disable(in);



	dssdev->state = OMAP_DSS_DISPLAY_DISABLED;

}



static void tvc_set_timings(struct omap_dss_device *dssdev,

		struct omap_video_timings *timings)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	ddata->timings = *timings;

	dssdev->panel.timings = *timings;



	in->ops.atv->set_timings(in, timings);

}



static void tvc_get_timings(struct omap_dss_device *dssdev,

		struct omap_video_timings *timings)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);



	*timings = ddata->timings;

}



static int tvc_check_timings(struct omap_dss_device *dssdev,

		struct omap_video_timings *timings)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	return in->ops.atv->check_timings(in, timings);

}



static u32 tvc_get_wss(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	return in->ops.atv->get_wss(in);

}



static int tvc_set_wss(struct omap_dss_device *dssdev, u32 wss)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	return in->ops.atv->set_wss(in, wss);

}



static struct omap_dss_driver tvc_driver = {

	.connect		= tvc_connect,

	.disconnect		= tvc_disconnect,



	.enable			= tvc_enable,

	.disable		= tvc_disable,



	.set_timings		= tvc_set_timings,

	.get_timings		= tvc_get_timings,

	.check_timings		= tvc_check_timings,



	.get_resolution		= omapdss_default_get_resolution,



	.get_wss		= tvc_get_wss,

	.set_wss		= tvc_set_wss,

};



static int tvc_probe_pdata(struct platform_device *pdev)

{

	struct panel_drv_data *ddata = platform_get_drvdata(pdev);

	struct connector_atv_platform_data *pdata;

	struct omap_dss_device *in, *dssdev;



	pdata = dev_get_platdata(&pdev->dev);



	in = omap_dss_find_output(pdata->source);

	if (in == NULL) {

		dev_err(&pdev->dev, "Failed to find video source\n");

		return -EPROBE_DEFER;

	}



	ddata->in = in;



	ddata->connector_type = pdata->connector_type;

	ddata->invert_polarity = pdata->invert_polarity;



	dssdev = &ddata->dssdev;

	dssdev->name = pdata->name;



	return 0;

}



static int tvc_probe_of(struct platform_device *pdev)

{

	struct panel_drv_data *ddata = platform_get_drvdata(pdev);

	struct device_node *node = pdev->dev.of_node;

	struct omap_dss_device *in;



	in = omapdss_of_find_source_for_first_ep(node);

	if (IS_ERR(in)) {

		dev_err(&pdev->dev, "failed to find video source\n");

		return PTR_ERR(in);

	}



	ddata->in = in;



	return 0;

}



static int tvc_probe(struct platform_device *pdev)

{

	struct panel_drv_data *ddata;

	struct omap_dss_device *dssdev;

	int r;



	ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);

	if (!ddata)

		return -ENOMEM;



	platform_set_drvdata(pdev, ddata);

	ddata->dev = &pdev->dev;



	if (dev_get_platdata(&pdev->dev)) {

		r = tvc_probe_pdata(pdev);

		if (r)

			return r;

	} else if (pdev->dev.of_node) {

		r = tvc_probe_of(pdev);

		if (r)

			return r;

	} else {

		return -ENODEV;

	}



	ddata->timings = tvc_pal_timings;



	dssdev = &ddata->dssdev;

	dssdev->driver = &tvc_driver;

	dssdev->dev = &pdev->dev;

	dssdev->type = OMAP_DISPLAY_TYPE_VENC;

	dssdev->owner = THIS_MODULE;

	dssdev->panel.timings = tvc_pal_timings;



	r = omapdss_register_display(dssdev);

	if (r) {

		dev_err(&pdev->dev, "Failed to register panel\n");

		goto err_reg;

	}



	return 0;

err_reg:

	omap_dss_put_device(ddata->in);

	return r;

}



static int __exit tvc_remove(struct platform_device *pdev)

{

	struct panel_drv_data *ddata = platform_get_drvdata(pdev);

	struct omap_dss_device *dssdev = &ddata->dssdev;

	struct omap_dss_device *in = ddata->in;



	omapdss_unregister_display(&ddata->dssdev);



	tvc_disable(dssdev);

	tvc_disconnect(dssdev);



	omap_dss_put_device(in);



	return 0;

}



static const struct of_device_id tvc_of_match[] = {

	{ .compatible = "omapdss,svideo-connector", },

	{ .compatible = "omapdss,composite-video-connector", },

	{},

};



MODULE_DEVICE_TABLE(of, tvc_of_match);



static struct platform_driver tvc_connector_driver = {

	.probe	= tvc_probe,

	.remove	= __exit_p(tvc_remove),

	.driver	= {

		.name	= "connector-analog-tv",

		.of_match_table = tvc_of_match,

		.suppress_bind_attrs = true,

	},

};



module_platform_driver(tvc_connector_driver);



MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");

MODULE_DESCRIPTION("Analog TV Connector driver");

MODULE_LICENSE("GPL");

drivers/video/fbdev/omap2/omapfb/displays/connector-dvi.c

0 → 100644
+398 −0
Original line number Diff line number Diff line 
/*

 * Generic DVI Connector driver

 *

 * Copyright (C) 2013 Texas Instruments

 * Author: Tomi Valkeinen <tomi.valkeinen@ti.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/i2c.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/slab.h>



#include <drm/drm_edid.h>



#include <video/omapdss.h>

#include <video/omap-panel-data.h>



static const struct omap_video_timings dvic_default_timings = {

	.x_res		= 640,

	.y_res		= 480,



	.pixelclock	= 23500000,



	.hfp		= 48,

	.hsw		= 32,

	.hbp		= 80,



	.vfp		= 3,

	.vsw		= 4,

	.vbp		= 7,



	.vsync_level	= OMAPDSS_SIG_ACTIVE_HIGH,

	.hsync_level	= OMAPDSS_SIG_ACTIVE_HIGH,

	.data_pclk_edge	= OMAPDSS_DRIVE_SIG_RISING_EDGE,

	.de_level	= OMAPDSS_SIG_ACTIVE_HIGH,

	.sync_pclk_edge	= OMAPDSS_DRIVE_SIG_FALLING_EDGE,

};



struct panel_drv_data {

	struct omap_dss_device dssdev;

	struct omap_dss_device *in;



	struct omap_video_timings timings;



	struct i2c_adapter *i2c_adapter;

};



#define to_panel_data(x) container_of(x, struct panel_drv_data, dssdev)



static int dvic_connect(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;

	int r;



	if (omapdss_device_is_connected(dssdev))

		return 0;



	r = in->ops.dvi->connect(in, dssdev);

	if (r)

		return r;



	return 0;

}



static void dvic_disconnect(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	if (!omapdss_device_is_connected(dssdev))

		return;



	in->ops.dvi->disconnect(in, dssdev);

}



static int dvic_enable(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;

	int r;



	if (!omapdss_device_is_connected(dssdev))

		return -ENODEV;



	if (omapdss_device_is_enabled(dssdev))

		return 0;



	in->ops.dvi->set_timings(in, &ddata->timings);



	r = in->ops.dvi->enable(in);

	if (r)

		return r;



	dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;



	return 0;

}



static void dvic_disable(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	if (!omapdss_device_is_enabled(dssdev))

		return;



	in->ops.dvi->disable(in);



	dssdev->state = OMAP_DSS_DISPLAY_DISABLED;

}



static void dvic_set_timings(struct omap_dss_device *dssdev,

		struct omap_video_timings *timings)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	ddata->timings = *timings;

	dssdev->panel.timings = *timings;



	in->ops.dvi->set_timings(in, timings);

}



static void dvic_get_timings(struct omap_dss_device *dssdev,

		struct omap_video_timings *timings)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);



	*timings = ddata->timings;

}



static int dvic_check_timings(struct omap_dss_device *dssdev,

		struct omap_video_timings *timings)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	struct omap_dss_device *in = ddata->in;



	return in->ops.dvi->check_timings(in, timings);

}



static int dvic_ddc_read(struct i2c_adapter *adapter,

		unsigned char *buf, u16 count, u8 offset)

{

	int r, retries;



	for (retries = 3; retries > 0; retries--) {

		struct i2c_msg msgs[] = {

			{

				.addr   = DDC_ADDR,

				.flags  = 0,

				.len    = 1,

				.buf    = &offset,

			}, {

				.addr   = DDC_ADDR,

				.flags  = I2C_M_RD,

				.len    = count,

				.buf    = buf,

			}

		};



		r = i2c_transfer(adapter, msgs, 2);

		if (r == 2)

			return 0;



		if (r != -EAGAIN)

			break;

	}



	return r < 0 ? r : -EIO;

}



static int dvic_read_edid(struct omap_dss_device *dssdev,

		u8 *edid, int len)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	int r, l, bytes_read;



	if (!ddata->i2c_adapter)

		return -ENODEV;



	l = min(EDID_LENGTH, len);

	r = dvic_ddc_read(ddata->i2c_adapter, edid, l, 0);

	if (r)

		return r;



	bytes_read = l;



	/* if there are extensions, read second block */

	if (len > EDID_LENGTH && edid[0x7e] > 0) {

		l = min(EDID_LENGTH, len - EDID_LENGTH);



		r = dvic_ddc_read(ddata->i2c_adapter, edid + EDID_LENGTH,

				l, EDID_LENGTH);

		if (r)

			return r;



		bytes_read += l;

	}



	return bytes_read;

}



static bool dvic_detect(struct omap_dss_device *dssdev)

{

	struct panel_drv_data *ddata = to_panel_data(dssdev);

	unsigned char out;

	int r;



	if (!ddata->i2c_adapter)

		return true;



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



	return r == 0;

}



static struct omap_dss_driver dvic_driver = {

	.connect	= dvic_connect,

	.disconnect	= dvic_disconnect,



	.enable		= dvic_enable,

	.disable	= dvic_disable,



	.set_timings	= dvic_set_timings,

	.get_timings	= dvic_get_timings,

	.check_timings	= dvic_check_timings,



	.get_resolution	= omapdss_default_get_resolution,



	.read_edid	= dvic_read_edid,

	.detect		= dvic_detect,

};



static int dvic_probe_pdata(struct platform_device *pdev)

{

	struct panel_drv_data *ddata = platform_get_drvdata(pdev);

	struct connector_dvi_platform_data *pdata;

	struct omap_dss_device *in, *dssdev;

	int i2c_bus_num;



	pdata = dev_get_platdata(&pdev->dev);

	i2c_bus_num = pdata->i2c_bus_num;



	if (i2c_bus_num != -1) {

		struct i2c_adapter *adapter;



		adapter = i2c_get_adapter(i2c_bus_num);

		if (!adapter) {

			dev_err(&pdev->dev,

					"Failed to get I2C adapter, bus %d\n",

					i2c_bus_num);

			return -EPROBE_DEFER;

		}



		ddata->i2c_adapter = adapter;

	}



	in = omap_dss_find_output(pdata->source);

	if (in == NULL) {

		i2c_put_adapter(ddata->i2c_adapter);



		dev_err(&pdev->dev, "Failed to find video source\n");

		return -EPROBE_DEFER;

	}



	ddata->in = in;



	dssdev = &ddata->dssdev;

	dssdev->name = pdata->name;



	return 0;

}



static int dvic_probe_of(struct platform_device *pdev)

{

	struct panel_drv_data *ddata = platform_get_drvdata(pdev);

	struct device_node *node = pdev->dev.of_node;

	struct omap_dss_device *in;

	struct device_node *adapter_node;

	struct i2c_adapter *adapter;



	in = omapdss_of_find_source_for_first_ep(node);

	if (IS_ERR(in)) {

		dev_err(&pdev->dev, "failed to find video source\n");

		return PTR_ERR(in);

	}



	ddata->in = in;



	adapter_node = of_parse_phandle(node, "ddc-i2c-bus", 0);

	if (adapter_node) {

		adapter = of_get_i2c_adapter_by_node(adapter_node);

		if (adapter == NULL) {

			dev_err(&pdev->dev, "failed to parse ddc-i2c-bus\n");

			omap_dss_put_device(ddata->in);

			return -EPROBE_DEFER;

		}



		ddata->i2c_adapter = adapter;

	}



	return 0;

}



static int dvic_probe(struct platform_device *pdev)

{

	struct panel_drv_data *ddata;

	struct omap_dss_device *dssdev;

	int r;



	ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);

	if (!ddata)

		return -ENOMEM;



	platform_set_drvdata(pdev, ddata);



	if (dev_get_platdata(&pdev->dev)) {

		r = dvic_probe_pdata(pdev);

		if (r)

			return r;

	} else if (pdev->dev.of_node) {

		r = dvic_probe_of(pdev);

		if (r)

			return r;

	} else {

		return -ENODEV;

	}



	ddata->timings = dvic_default_timings;



	dssdev = &ddata->dssdev;

	dssdev->driver = &dvic_driver;

	dssdev->dev = &pdev->dev;

	dssdev->type = OMAP_DISPLAY_TYPE_DVI;

	dssdev->owner = THIS_MODULE;

	dssdev->panel.timings = dvic_default_timings;



	r = omapdss_register_display(dssdev);

	if (r) {

		dev_err(&pdev->dev, "Failed to register panel\n");

		goto err_reg;

	}



	return 0;



err_reg:

	omap_dss_put_device(ddata->in);



	i2c_put_adapter(ddata->i2c_adapter);



	return r;

}



static int __exit dvic_remove(struct platform_device *pdev)

{

	struct panel_drv_data *ddata = platform_get_drvdata(pdev);

	struct omap_dss_device *dssdev = &ddata->dssdev;

	struct omap_dss_device *in = ddata->in;



	omapdss_unregister_display(&ddata->dssdev);



	dvic_disable(dssdev);

	dvic_disconnect(dssdev);



	omap_dss_put_device(in);



	i2c_put_adapter(ddata->i2c_adapter);



	return 0;

}



static const struct of_device_id dvic_of_match[] = {

	{ .compatible = "omapdss,dvi-connector", },

	{},

};



MODULE_DEVICE_TABLE(of, dvic_of_match);



static struct platform_driver dvi_connector_driver = {

	.probe	= dvic_probe,

	.remove	= __exit_p(dvic_remove),

	.driver	= {

		.name	= "connector-dvi",

		.of_match_table = dvic_of_match,

		.suppress_bind_attrs = true,

	},

};



module_platform_driver(dvi_connector_driver);



MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");

MODULE_DESCRIPTION("Generic DVI Connector driver");

MODULE_LICENSE("GPL");