[mirror_ubuntu-focal-kernel.git] / drivers / gpu / drm / tilcdc / tilcdc_tfp410.c

/*
 * Copyright (C) 2012 Texas Instruments
 * Author: Rob Clark <robdclark@gmail.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.
 *
 * 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/>.
 */

#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/pinctrl/pinmux.h>
#include <linux/pinctrl/consumer.h>
#include <drm/drm_atomic_helper.h>

#include "tilcdc_drv.h"
#include "tilcdc_tfp410.h"

struct tfp410_module {
	struct tilcdc_module base;
	struct i2c_adapter *i2c;
	int gpio;
};
#define to_tfp410_module(x) container_of(x, struct tfp410_module, base)


static const struct tilcdc_panel_info dvi_info = {
		.ac_bias                = 255,
		.ac_bias_intrpt         = 0,
		.dma_burst_sz           = 16,
		.bpp                    = 16,
		.fdd                    = 0x80,
		.tft_alt_mode           = 0,
		.sync_edge              = 0,
		.sync_ctrl              = 1,
		.raster_order           = 0,
};

/*
 * Encoder:
 */

struct tfp410_encoder {
	struct drm_encoder base;
	struct tfp410_module *mod;
	int dpms;
};
#define to_tfp410_encoder(x) container_of(x, struct tfp410_encoder, base)

static void tfp410_encoder_dpms(struct drm_encoder *encoder, int mode)
{
	struct tfp410_encoder *tfp410_encoder = to_tfp410_encoder(encoder);

	if (tfp410_encoder->dpms == mode)
		return;

	if (mode == DRM_MODE_DPMS_ON) {
		DBG("Power on");
		gpio_direction_output(tfp410_encoder->mod->gpio, 1);
	} else {
		DBG("Power off");
		gpio_direction_output(tfp410_encoder->mod->gpio, 0);
	}

	tfp410_encoder->dpms = mode;
}

static void tfp410_encoder_prepare(struct drm_encoder *encoder)
{
	tfp410_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
}

static void tfp410_encoder_commit(struct drm_encoder *encoder)
{
	tfp410_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
}

static void tfp410_encoder_mode_set(struct drm_encoder *encoder,
		struct drm_display_mode *mode,
		struct drm_display_mode *adjusted_mode)
{
	/* nothing needed */
}

static const struct drm_encoder_funcs tfp410_encoder_funcs = {
		.destroy        = drm_encoder_cleanup,
};

static const struct drm_encoder_helper_funcs tfp410_encoder_helper_funcs = {
		.dpms           = tfp410_encoder_dpms,
		.prepare        = tfp410_encoder_prepare,
		.commit         = tfp410_encoder_commit,
		.mode_set       = tfp410_encoder_mode_set,
};

static struct drm_encoder *tfp410_encoder_create(struct drm_device *dev,
		struct tfp410_module *mod)
{
	struct tfp410_encoder *tfp410_encoder;
	struct drm_encoder *encoder;
	int ret;

	tfp410_encoder = devm_kzalloc(dev->dev, sizeof(*tfp410_encoder),
				      GFP_KERNEL);
	if (!tfp410_encoder) {
		dev_err(dev->dev, "allocation failed\n");
		return NULL;
	}

	tfp410_encoder->dpms = DRM_MODE_DPMS_OFF;
	tfp410_encoder->mod = mod;

	encoder = &tfp410_encoder->base;
	encoder->possible_crtcs = 1;

	ret = drm_encoder_init(dev, encoder, &tfp410_encoder_funcs,
			DRM_MODE_ENCODER_TMDS, NULL);
	if (ret < 0)
		goto fail;

	drm_encoder_helper_add(encoder, &tfp410_encoder_helper_funcs);

	return encoder;

fail:
	drm_encoder_cleanup(encoder);
	return NULL;
}

/*
 * Connector:
 */

struct tfp410_connector {
	struct drm_connector base;

	struct drm_encoder *encoder;  /* our connected encoder */
	struct tfp410_module *mod;
};
#define to_tfp410_connector(x) container_of(x, struct tfp410_connector, base)


static void tfp410_connector_destroy(struct drm_connector *connector)
{
	drm_connector_unregister(connector);
	drm_connector_cleanup(connector);
}

static enum drm_connector_status tfp410_connector_detect(
		struct drm_connector *connector,
		bool force)
{
	struct tfp410_connector *tfp410_connector = to_tfp410_connector(connector);

	if (drm_probe_ddc(tfp410_connector->mod->i2c))
		return connector_status_connected;

	return connector_status_unknown;
}

static int tfp410_connector_get_modes(struct drm_connector *connector)
{
	struct tfp410_connector *tfp410_connector = to_tfp410_connector(connector);
	struct edid *edid;
	int ret = 0;

	edid = drm_get_edid(connector, tfp410_connector->mod->i2c);

	drm_mode_connector_update_edid_property(connector, edid);

	if (edid) {
		ret = drm_add_edid_modes(connector, edid);
		kfree(edid);
	}

	return ret;
}

static int tfp410_connector_mode_valid(struct drm_connector *connector,
		  struct drm_display_mode *mode)
{
	struct tilcdc_drm_private *priv = connector->dev->dev_private;
	/* our only constraints are what the crtc can generate: */
	return tilcdc_crtc_mode_valid(priv->crtc, mode);
}

static struct drm_encoder *tfp410_connector_best_encoder(
		struct drm_connector *connector)
{
	struct tfp410_connector *tfp410_connector = to_tfp410_connector(connector);
	return tfp410_connector->encoder;
}

static const struct drm_connector_funcs tfp410_connector_funcs = {
	.destroy            = tfp410_connector_destroy,
	.detect             = tfp410_connector_detect,
	.fill_modes         = drm_helper_probe_single_connector_modes,
	.reset              = drm_atomic_helper_connector_reset,
	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};

static const struct drm_connector_helper_funcs tfp410_connector_helper_funcs = {
	.get_modes          = tfp410_connector_get_modes,
	.mode_valid         = tfp410_connector_mode_valid,
	.best_encoder       = tfp410_connector_best_encoder,
};

static struct drm_connector *tfp410_connector_create(struct drm_device *dev,
		struct tfp410_module *mod, struct drm_encoder *encoder)
{
	struct tfp410_connector *tfp410_connector;
	struct drm_connector *connector;
	int ret;

	tfp410_connector = devm_kzalloc(dev->dev, sizeof(*tfp410_connector),
					GFP_KERNEL);
	if (!tfp410_connector) {
		dev_err(dev->dev, "allocation failed\n");
		return NULL;
	}

	tfp410_connector->encoder = encoder;
	tfp410_connector->mod = mod;

	connector = &tfp410_connector->base;

	drm_connector_init(dev, connector, &tfp410_connector_funcs,
			DRM_MODE_CONNECTOR_DVID);
	drm_connector_helper_add(connector, &tfp410_connector_helper_funcs);

	connector->polled = DRM_CONNECTOR_POLL_CONNECT |
			DRM_CONNECTOR_POLL_DISCONNECT;

	connector->interlace_allowed = 0;
	connector->doublescan_allowed = 0;

	ret = drm_mode_connector_attach_encoder(connector, encoder);
	if (ret)
		goto fail;

	return connector;

fail:
	tfp410_connector_destroy(connector);
	return NULL;
}

/*
 * Module:
 */

static int tfp410_modeset_init(struct tilcdc_module *mod, struct drm_device *dev)
{
	struct tfp410_module *tfp410_mod = to_tfp410_module(mod);
	struct tilcdc_drm_private *priv = dev->dev_private;
	struct drm_encoder *encoder;
	struct drm_connector *connector;

	encoder = tfp410_encoder_create(dev, tfp410_mod);
	if (!encoder)
		return -ENOMEM;

	connector = tfp410_connector_create(dev, tfp410_mod, encoder);
	if (!connector)
		return -ENOMEM;

	priv->encoders[priv->num_encoders++] = encoder;
	priv->connectors[priv->num_connectors++] = connector;

	tilcdc_crtc_set_panel_info(priv->crtc, &dvi_info);
	return 0;
}

static const struct tilcdc_module_ops tfp410_module_ops = {
		.modeset_init = tfp410_modeset_init,
};

/*
 * Device:
 */

static int tfp410_probe(struct platform_device *pdev)
{
	struct device_node *node = pdev->dev.of_node;
	struct device_node *i2c_node;
	struct tfp410_module *tfp410_mod;
	struct tilcdc_module *mod;
	struct pinctrl *pinctrl;
	uint32_t i2c_phandle;
	int ret = -EINVAL;

	/* bail out early if no DT data: */
	if (!node) {
		dev_err(&pdev->dev, "device-tree data is missing\n");
		return -ENXIO;
	}

	tfp410_mod = devm_kzalloc(&pdev->dev, sizeof(*tfp410_mod), GFP_KERNEL);
	if (!tfp410_mod)
		return -ENOMEM;

	mod = &tfp410_mod->base;
	pdev->dev.platform_data = mod;

	tilcdc_module_init(mod, "tfp410", &tfp410_module_ops);

	pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
	if (IS_ERR(pinctrl))
		dev_warn(&pdev->dev, "pins are not configured\n");

	if (of_property_read_u32(node, "i2c", &i2c_phandle)) {
		dev_err(&pdev->dev, "could not get i2c bus phandle\n");
		goto fail;
	}

	i2c_node = of_find_node_by_phandle(i2c_phandle);
	if (!i2c_node) {
		dev_err(&pdev->dev, "could not get i2c bus node\n");
		goto fail;
	}

	tfp410_mod->i2c = of_find_i2c_adapter_by_node(i2c_node);
	if (!tfp410_mod->i2c) {
		dev_err(&pdev->dev, "could not get i2c\n");
		of_node_put(i2c_node);
		goto fail;
	}

	of_node_put(i2c_node);

	tfp410_mod->gpio = of_get_named_gpio_flags(node, "powerdn-gpio",
			0, NULL);
	if (tfp410_mod->gpio < 0) {
		dev_warn(&pdev->dev, "No power down GPIO\n");
	} else {
		ret = gpio_request(tfp410_mod->gpio, "DVI_PDn");
		if (ret) {
			dev_err(&pdev->dev, "could not get DVI_PDn gpio\n");
			goto fail_adapter;
		}
	}

	return 0;

fail_adapter:
	i2c_put_adapter(tfp410_mod->i2c);

fail:
	tilcdc_module_cleanup(mod);
	return ret;
}

static int tfp410_remove(struct platform_device *pdev)
{
	struct tilcdc_module *mod = dev_get_platdata(&pdev->dev);
	struct tfp410_module *tfp410_mod = to_tfp410_module(mod);

	i2c_put_adapter(tfp410_mod->i2c);
	gpio_free(tfp410_mod->gpio);

	tilcdc_module_cleanup(mod);

	return 0;
}

static const struct of_device_id tfp410_of_match[] = {
		{ .compatible = "ti,tilcdc,tfp410", },
		{ },
};

struct platform_driver tfp410_driver = {
	.probe = tfp410_probe,
	.remove = tfp410_remove,
	.driver = {
		.owner = THIS_MODULE,
		.name = "tfp410",
		.of_match_table = tfp410_of_match,
	},
};

int __init tilcdc_tfp410_init(void)
{
	return platform_driver_register(&tfp410_driver);
}

void __exit tilcdc_tfp410_fini(void)
{
	platform_driver_unregister(&tfp410_driver);
}
Commit	Line	Data
16ea975e RC	1	/*
	2	* Copyright (C) 2012 Texas Instruments
	3	* Author: Rob Clark <robdclark@gmail.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program. If not, see <http://www.gnu.org/licenses/>.
	16	*/
	17
	18	#include <linux/i2c.h>
16ea975e RC	19	#include <linux/gpio.h>
	20	#include <linux/of_gpio.h>
	21	#include <linux/pinctrl/pinmux.h>
	22	#include <linux/pinctrl/consumer.h>
018cfbde	23	#include <drm/drm_atomic_helper.h>
16ea975e RC	24
16ea975e RC	25	#include "tilcdc_drv.h"
0fd86779	26	#include "tilcdc_tfp410.h"
16ea975e RC	27
	28	struct tfp410_module {
	29	struct tilcdc_module base;
	30	struct i2c_adapter *i2c;
	31	int gpio;
	32	};
	33	#define to_tfp410_module(x) container_of(x, struct tfp410_module, base)
	34
	35
	36	static const struct tilcdc_panel_info dvi_info = {
	37	.ac_bias = 255,
	38	.ac_bias_intrpt = 0,
	39	.dma_burst_sz = 16,
	40	.bpp = 16,
	41	.fdd = 0x80,
	42	.tft_alt_mode = 0,
	43	.sync_edge = 0,
	44	.sync_ctrl = 1,
	45	.raster_order = 0,
	46	};
	47
	48	/*
	49	* Encoder:
	50	*/
	51
	52	struct tfp410_encoder {
	53	struct drm_encoder base;
	54	struct tfp410_module *mod;
	55	int dpms;
	56	};
	57	#define to_tfp410_encoder(x) container_of(x, struct tfp410_encoder, base)
	58
16ea975e RC	59	static void tfp410_encoder_dpms(struct drm_encoder *encoder, int mode)
	60	{
	61	struct tfp410_encoder *tfp410_encoder = to_tfp410_encoder(encoder);
	62
	63	if (tfp410_encoder->dpms == mode)
	64	return;
	65
	66	if (mode == DRM_MODE_DPMS_ON) {
	67	DBG("Power on");
	68	gpio_direction_output(tfp410_encoder->mod->gpio, 1);
	69	} else {
	70	DBG("Power off");
	71	gpio_direction_output(tfp410_encoder->mod->gpio, 0);
	72	}
	73
	74	tfp410_encoder->dpms = mode;
	75	}
	76
16ea975e RC	77	static void tfp410_encoder_prepare(struct drm_encoder *encoder)
	78	{
	79	tfp410_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
16ea975e RC	80	}
	81
	82	static void tfp410_encoder_commit(struct drm_encoder *encoder)
	83	{
	84	tfp410_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
	85	}
	86
	87	static void tfp410_encoder_mode_set(struct drm_encoder *encoder,
	88	struct drm_display_mode *mode,
	89	struct drm_display_mode *adjusted_mode)
	90	{
	91	/* nothing needed */
	92	}
	93
	94	static const struct drm_encoder_funcs tfp410_encoder_funcs = {
d0ec32ca	95	.destroy = drm_encoder_cleanup,
16ea975e RC	96	};
	97
	98	static const struct drm_encoder_helper_funcs tfp410_encoder_helper_funcs = {
	99	.dpms = tfp410_encoder_dpms,
16ea975e RC	100	.prepare = tfp410_encoder_prepare,
	101	.commit = tfp410_encoder_commit,
	102	.mode_set = tfp410_encoder_mode_set,
	103	};
	104
	105	static struct drm_encoder tfp410_encoder_create(struct drm_device dev,
	106	struct tfp410_module *mod)
	107	{
	108	struct tfp410_encoder *tfp410_encoder;
	109	struct drm_encoder *encoder;
	110	int ret;
	111
d0ec32ca JS	112	tfp410_encoder = devm_kzalloc(dev->dev, sizeof(*tfp410_encoder),
d0ec32ca JS	113	GFP_KERNEL);
16ea975e RC	114	if (!tfp410_encoder) {
	115	dev_err(dev->dev, "allocation failed\n");
	116	return NULL;
	117	}
	118
	119	tfp410_encoder->dpms = DRM_MODE_DPMS_OFF;
	120	tfp410_encoder->mod = mod;
	121
	122	encoder = &tfp410_encoder->base;
	123	encoder->possible_crtcs = 1;
	124
	125	ret = drm_encoder_init(dev, encoder, &tfp410_encoder_funcs,
13a3d91f	126	DRM_MODE_ENCODER_TMDS, NULL);
16ea975e RC	127	if (ret < 0)
	128	goto fail;
	129
	130	drm_encoder_helper_add(encoder, &tfp410_encoder_helper_funcs);
	131
	132	return encoder;
	133
	134	fail:
d0ec32ca	135	drm_encoder_cleanup(encoder);
16ea975e RC	136	return NULL;
	137	}
	138
	139	/*
	140	* Connector:
	141	*/
	142
	143	struct tfp410_connector {
	144	struct drm_connector base;
	145
	146	struct drm_encoder encoder; / our connected encoder */
	147	struct tfp410_module *mod;
	148	};
	149	#define to_tfp410_connector(x) container_of(x, struct tfp410_connector, base)
	150
	151
	152	static void tfp410_connector_destroy(struct drm_connector *connector)
	153	{
62eb3e20	154	drm_connector_unregister(connector);
16ea975e	155	drm_connector_cleanup(connector);
16ea975e RC	156	}
	157
	158	static enum drm_connector_status tfp410_connector_detect(
	159	struct drm_connector *connector,
	160	bool force)
	161	{
	162	struct tfp410_connector *tfp410_connector = to_tfp410_connector(connector);
	163
	164	if (drm_probe_ddc(tfp410_connector->mod->i2c))
	165	return connector_status_connected;
	166
	167	return connector_status_unknown;
	168	}
	169
	170	static int tfp410_connector_get_modes(struct drm_connector *connector)
	171	{
	172	struct tfp410_connector *tfp410_connector = to_tfp410_connector(connector);
	173	struct edid *edid;
	174	int ret = 0;
	175
	176	edid = drm_get_edid(connector, tfp410_connector->mod->i2c);
	177
	178	drm_mode_connector_update_edid_property(connector, edid);
	179
	180	if (edid) {
	181	ret = drm_add_edid_modes(connector, edid);
	182	kfree(edid);
	183	}
	184
	185	return ret;
	186	}
	187
	188	static int tfp410_connector_mode_valid(struct drm_connector *connector,
	189	struct drm_display_mode *mode)
	190	{
	191	struct tilcdc_drm_private *priv = connector->dev->dev_private;
	192	/* our only constraints are what the crtc can generate: */
	193	return tilcdc_crtc_mode_valid(priv->crtc, mode);
	194	}
	195
	196	static struct drm_encoder *tfp410_connector_best_encoder(
	197	struct drm_connector *connector)
	198	{
	199	struct tfp410_connector *tfp410_connector = to_tfp410_connector(connector);
	200	return tfp410_connector->encoder;
	201	}
	202
	203	static const struct drm_connector_funcs tfp410_connector_funcs = {
	204	.destroy = tfp410_connector_destroy,
16ea975e RC	205	.detect = tfp410_connector_detect,
16ea975e RC	206	.fill_modes = drm_helper_probe_single_connector_modes,
018cfbde JS	207	.reset = drm_atomic_helper_connector_reset,
	208	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
	209	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
16ea975e RC	210	};
	211
	212	static const struct drm_connector_helper_funcs tfp410_connector_helper_funcs = {
	213	.get_modes = tfp410_connector_get_modes,
	214	.mode_valid = tfp410_connector_mode_valid,
	215	.best_encoder = tfp410_connector_best_encoder,
	216	};
	217
	218	static struct drm_connector tfp410_connector_create(struct drm_device dev,
	219	struct tfp410_module mod, struct drm_encoder encoder)
	220	{
	221	struct tfp410_connector *tfp410_connector;
	222	struct drm_connector *connector;
	223	int ret;
	224
d0ec32ca JS	225	tfp410_connector = devm_kzalloc(dev->dev, sizeof(*tfp410_connector),
d0ec32ca JS	226	GFP_KERNEL);
16ea975e RC	227	if (!tfp410_connector) {
	228	dev_err(dev->dev, "allocation failed\n");
	229	return NULL;
	230	}
	231
	232	tfp410_connector->encoder = encoder;
	233	tfp410_connector->mod = mod;
	234
	235	connector = &tfp410_connector->base;
	236
	237	drm_connector_init(dev, connector, &tfp410_connector_funcs,
	238	DRM_MODE_CONNECTOR_DVID);
	239	drm_connector_helper_add(connector, &tfp410_connector_helper_funcs);
	240
	241	connector->polled = DRM_CONNECTOR_POLL_CONNECT \|
	242	DRM_CONNECTOR_POLL_DISCONNECT;
	243
	244	connector->interlace_allowed = 0;
	245	connector->doublescan_allowed = 0;
	246
	247	ret = drm_mode_connector_attach_encoder(connector, encoder);
	248	if (ret)
	249	goto fail;
	250
16ea975e RC	251	return connector;
	252
	253	fail:
	254	tfp410_connector_destroy(connector);
	255	return NULL;
	256	}
	257
	258	/*
	259	* Module:
	260	*/
	261
	262	static int tfp410_modeset_init(struct tilcdc_module mod, struct drm_device dev)
	263	{
	264	struct tfp410_module *tfp410_mod = to_tfp410_module(mod);
	265	struct tilcdc_drm_private *priv = dev->dev_private;
	266	struct drm_encoder *encoder;
	267	struct drm_connector *connector;
	268
	269	encoder = tfp410_encoder_create(dev, tfp410_mod);
	270	if (!encoder)
	271	return -ENOMEM;
	272
	273	connector = tfp410_connector_create(dev, tfp410_mod, encoder);
	274	if (!connector)
	275	return -ENOMEM;
	276
	277	priv->encoders[priv->num_encoders++] = encoder;
	278	priv->connectors[priv->num_connectors++] = connector;
	279
7c979b55	280	tilcdc_crtc_set_panel_info(priv->crtc, &dvi_info);
16ea975e RC	281	return 0;
	282	}
	283
16ea975e RC	284	static const struct tilcdc_module_ops tfp410_module_ops = {
16ea975e RC	285	.modeset_init = tfp410_modeset_init,
16ea975e RC	286	};
	287
	288	/*
	289	* Device:
	290	*/
	291
16ea975e RC	292	static int tfp410_probe(struct platform_device *pdev)
	293	{
	294	struct device_node *node = pdev->dev.of_node;
	295	struct device_node *i2c_node;
	296	struct tfp410_module *tfp410_mod;
	297	struct tilcdc_module *mod;
	298	struct pinctrl *pinctrl;
	299	uint32_t i2c_phandle;
	300	int ret = -EINVAL;
	301
	302	/* bail out early if no DT data: */
	303	if (!node) {
	304	dev_err(&pdev->dev, "device-tree data is missing\n");
	305	return -ENXIO;
	306	}
	307
d0ec32ca	308	tfp410_mod = devm_kzalloc(&pdev->dev, sizeof(*tfp410_mod), GFP_KERNEL);
16ea975e RC	309	if (!tfp410_mod)
	310	return -ENOMEM;
	311
	312	mod = &tfp410_mod->base;
7cdcce9f	313	pdev->dev.platform_data = mod;
16ea975e RC	314
	315	tilcdc_module_init(mod, "tfp410", &tfp410_module_ops);
	316
	317	pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
	318	if (IS_ERR(pinctrl))
	319	dev_warn(&pdev->dev, "pins are not configured\n");
	320
	321	if (of_property_read_u32(node, "i2c", &i2c_phandle)) {
	322	dev_err(&pdev->dev, "could not get i2c bus phandle\n");
	323	goto fail;
	324	}
	325
	326	i2c_node = of_find_node_by_phandle(i2c_phandle);
	327	if (!i2c_node) {
	328	dev_err(&pdev->dev, "could not get i2c bus node\n");
	329	goto fail;
	330	}
	331
	332	tfp410_mod->i2c = of_find_i2c_adapter_by_node(i2c_node);
	333	if (!tfp410_mod->i2c) {
	334	dev_err(&pdev->dev, "could not get i2c\n");
7cdcce9f	335	of_node_put(i2c_node);
16ea975e RC	336	goto fail;
	337	}
	338
	339	of_node_put(i2c_node);
	340
	341	tfp410_mod->gpio = of_get_named_gpio_flags(node, "powerdn-gpio",
	342	0, NULL);
287980e4	343	if (tfp410_mod->gpio < 0) {
16ea975e RC	344	dev_warn(&pdev->dev, "No power down GPIO\n");
	345	} else {
	346	ret = gpio_request(tfp410_mod->gpio, "DVI_PDn");
	347	if (ret) {
	348	dev_err(&pdev->dev, "could not get DVI_PDn gpio\n");
7cdcce9f	349	goto fail_adapter;
16ea975e RC	350	}
	351	}
	352
	353	return 0;
	354
7cdcce9f GM	355	fail_adapter:
	356	i2c_put_adapter(tfp410_mod->i2c);
	357
16ea975e	358	fail:
7cdcce9f	359	tilcdc_module_cleanup(mod);
16ea975e RC	360	return ret;
	361	}
	362
	363	static int tfp410_remove(struct platform_device *pdev)
	364	{
7cdcce9f GM	365	struct tilcdc_module *mod = dev_get_platdata(&pdev->dev);
	366	struct tfp410_module *tfp410_mod = to_tfp410_module(mod);
	367
	368	i2c_put_adapter(tfp410_mod->i2c);
	369	gpio_free(tfp410_mod->gpio);
	370
	371	tilcdc_module_cleanup(mod);
7cdcce9f	372
16ea975e RC	373	return 0;
	374	}
	375
cafdee68	376	static const struct of_device_id tfp410_of_match[] = {
16ea975e RC	377	{ .compatible = "ti,tilcdc,tfp410", },
	378	{ },
	379	};
16ea975e RC	380
	381	struct platform_driver tfp410_driver = {
	382	.probe = tfp410_probe,
	383	.remove = tfp410_remove,
	384	.driver = {
	385	.owner = THIS_MODULE,
	386	.name = "tfp410",
	387	.of_match_table = tfp410_of_match,
	388	},
	389	};
	390
	391	int __init tilcdc_tfp410_init(void)
	392	{
	393	return platform_driver_register(&tfp410_driver);
	394	}
	395
	396	void __exit tilcdc_tfp410_fini(void)
	397	{
	398	platform_driver_unregister(&tfp410_driver);
	399	}