1/*
  2 * HDMI Connector driver
  3 *
  4 * Copyright (C) 2013 Texas Instruments
  5 * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
  6 *
  7 * This program is free software; you can redistribute it and/or modify it
  8 * under the terms of the GNU General Public License version 2 as published by
  9 * the Free Software Foundation.
 10 */
 11
 12#include <linux/gpio/consumer.h>
 13#include <linux/slab.h>
 14#include <linux/module.h>
 15#include <linux/platform_device.h>
 16#include <linux/of.h>
 17#include <linux/of_gpio.h>
 18
 19#include <drm/drm_edid.h>
 20#include <video/omap-panel-data.h>
 21
 22#include "../dss/omapdss.h"
 23
 24static const struct videomode hdmic_default_vm = {
 25	.hactive	= 640,
 26	.vactive	= 480,
 27	.pixelclock	= 25175000,
 28	.hsync_len	= 96,
 29	.hfront_porch	= 16,
 30	.hback_porch	= 48,
 31	.vsync_len	= 2,
 32	.vfront_porch	= 11,
 33	.vback_porch	= 31,
 34
 35	.flags		= DISPLAY_FLAGS_HSYNC_LOW | DISPLAY_FLAGS_VSYNC_LOW,
 36};
 37
 38struct panel_drv_data {
 39	struct omap_dss_device dssdev;
 40	struct omap_dss_device *in;
 41
 42	struct device *dev;
 43
 44	struct videomode vm;
 45
 46	int hpd_gpio;
 47};
 48
 49#define to_panel_data(x) container_of(x, struct panel_drv_data, dssdev)
 50
 51static int hdmic_connect(struct omap_dss_device *dssdev)
 52{
 53	struct panel_drv_data *ddata = to_panel_data(dssdev);
 54	struct omap_dss_device *in = ddata->in;
 55	int r;
 56
 57	dev_dbg(ddata->dev, "connect\n");
 58
 59	if (omapdss_device_is_connected(dssdev))
 60		return 0;
 61
 62	r = in->ops.hdmi->connect(in, dssdev);
 63	if (r)
 64		return r;
 65
 66	return 0;
 67}
 68
 69static void hdmic_disconnect(struct omap_dss_device *dssdev)
 70{
 71	struct panel_drv_data *ddata = to_panel_data(dssdev);
 72	struct omap_dss_device *in = ddata->in;
 73
 74	dev_dbg(ddata->dev, "disconnect\n");
 75
 76	if (!omapdss_device_is_connected(dssdev))
 77		return;
 78
 79	in->ops.hdmi->disconnect(in, dssdev);
 80}
 81
 82static int hdmic_enable(struct omap_dss_device *dssdev)
 83{
 84	struct panel_drv_data *ddata = to_panel_data(dssdev);
 85	struct omap_dss_device *in = ddata->in;
 86	int r;
 87
 88	dev_dbg(ddata->dev, "enable\n");
 89
 90	if (!omapdss_device_is_connected(dssdev))
 91		return -ENODEV;
 92
 93	if (omapdss_device_is_enabled(dssdev))
 94		return 0;
 95
 96	in->ops.hdmi->set_timings(in, &ddata->vm);
 97
 98	r = in->ops.hdmi->enable(in);
 99	if (r)
100		return r;
101
102	dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
103
104	return r;
105}
106
107static void hdmic_disable(struct omap_dss_device *dssdev)
108{
109	struct panel_drv_data *ddata = to_panel_data(dssdev);
110	struct omap_dss_device *in = ddata->in;
111
112	dev_dbg(ddata->dev, "disable\n");
113
114	if (!omapdss_device_is_enabled(dssdev))
115		return;
116
117	in->ops.hdmi->disable(in);
118
119	dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
120}
121
122static void hdmic_set_timings(struct omap_dss_device *dssdev,
123			      struct videomode *vm)
124{
125	struct panel_drv_data *ddata = to_panel_data(dssdev);
126	struct omap_dss_device *in = ddata->in;
127
128	ddata->vm = *vm;
129	dssdev->panel.vm = *vm;
130
131	in->ops.hdmi->set_timings(in, vm);
132}
133
134static void hdmic_get_timings(struct omap_dss_device *dssdev,
135			      struct videomode *vm)
136{
137	struct panel_drv_data *ddata = to_panel_data(dssdev);
138
139	*vm = ddata->vm;
140}
141
142static int hdmic_check_timings(struct omap_dss_device *dssdev,
143			       struct videomode *vm)
144{
145	struct panel_drv_data *ddata = to_panel_data(dssdev);
146	struct omap_dss_device *in = ddata->in;
147
148	return in->ops.hdmi->check_timings(in, vm);
149}
150
151static int hdmic_read_edid(struct omap_dss_device *dssdev,
152		u8 *edid, int len)
153{
154	struct panel_drv_data *ddata = to_panel_data(dssdev);
155	struct omap_dss_device *in = ddata->in;
156
157	return in->ops.hdmi->read_edid(in, edid, len);
158}
159
160static bool hdmic_detect(struct omap_dss_device *dssdev)
161{
162	struct panel_drv_data *ddata = to_panel_data(dssdev);
163	struct omap_dss_device *in = ddata->in;
164
165	if (gpio_is_valid(ddata->hpd_gpio))
166		return gpio_get_value_cansleep(ddata->hpd_gpio);
167	else
168		return in->ops.hdmi->detect(in);
169}
170
171static int hdmic_set_hdmi_mode(struct omap_dss_device *dssdev, bool hdmi_mode)
172{
173	struct panel_drv_data *ddata = to_panel_data(dssdev);
174	struct omap_dss_device *in = ddata->in;
175
176	return in->ops.hdmi->set_hdmi_mode(in, hdmi_mode);
177}
178
179static int hdmic_set_infoframe(struct omap_dss_device *dssdev,
180		const struct hdmi_avi_infoframe *avi)
181{
182	struct panel_drv_data *ddata = to_panel_data(dssdev);
183	struct omap_dss_device *in = ddata->in;
184
185	return in->ops.hdmi->set_infoframe(in, avi);
186}
187
188static struct omap_dss_driver hdmic_driver = {
189	.connect		= hdmic_connect,
190	.disconnect		= hdmic_disconnect,
191
192	.enable			= hdmic_enable,
193	.disable		= hdmic_disable,
194
195	.set_timings		= hdmic_set_timings,
196	.get_timings		= hdmic_get_timings,
197	.check_timings		= hdmic_check_timings,
198
199	.get_resolution		= omapdss_default_get_resolution,
200
201	.read_edid		= hdmic_read_edid,
202	.detect			= hdmic_detect,
203	.set_hdmi_mode		= hdmic_set_hdmi_mode,
204	.set_hdmi_infoframe	= hdmic_set_infoframe,
205};
206
207static int hdmic_probe_of(struct platform_device *pdev)
208{
209	struct panel_drv_data *ddata = platform_get_drvdata(pdev);
210	struct device_node *node = pdev->dev.of_node;
211	struct omap_dss_device *in;
212	int gpio;
213
214	/* HPD GPIO */
215	gpio = of_get_named_gpio(node, "hpd-gpios", 0);
216	if (gpio_is_valid(gpio))
217		ddata->hpd_gpio = gpio;
218	else
219		ddata->hpd_gpio = -ENODEV;
220
221	in = omapdss_of_find_source_for_first_ep(node);
222	if (IS_ERR(in)) {
223		dev_err(&pdev->dev, "failed to find video source\n");
224		return PTR_ERR(in);
225	}
226
227	ddata->in = in;
228
229	return 0;
230}
231
232static int hdmic_probe(struct platform_device *pdev)
233{
234	struct panel_drv_data *ddata;
235	struct omap_dss_device *dssdev;
236	int r;
237
238	ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
239	if (!ddata)
240		return -ENOMEM;
241
242	platform_set_drvdata(pdev, ddata);
243	ddata->dev = &pdev->dev;
244
245	if (!pdev->dev.of_node)
246		return -ENODEV;
247
248	r = hdmic_probe_of(pdev);
249	if (r)
250		return r;
251
252	if (gpio_is_valid(ddata->hpd_gpio)) {
253		r = devm_gpio_request_one(&pdev->dev, ddata->hpd_gpio,
254				GPIOF_DIR_IN, "hdmi_hpd");
255		if (r)
256			goto err_reg;
257	}
258
259	ddata->vm = hdmic_default_vm;
260
261	dssdev = &ddata->dssdev;
262	dssdev->driver = &hdmic_driver;
263	dssdev->dev = &pdev->dev;
264	dssdev->type = OMAP_DISPLAY_TYPE_HDMI;
265	dssdev->owner = THIS_MODULE;
266	dssdev->panel.vm = hdmic_default_vm;
267
268	r = omapdss_register_display(dssdev);
269	if (r) {
270		dev_err(&pdev->dev, "Failed to register panel\n");
271		goto err_reg;
272	}
273
274	return 0;
275err_reg:
276	omap_dss_put_device(ddata->in);
277	return r;
278}
279
280static int __exit hdmic_remove(struct platform_device *pdev)
281{
282	struct panel_drv_data *ddata = platform_get_drvdata(pdev);
283	struct omap_dss_device *dssdev = &ddata->dssdev;
284	struct omap_dss_device *in = ddata->in;
285
286	omapdss_unregister_display(&ddata->dssdev);
287
288	hdmic_disable(dssdev);
289	hdmic_disconnect(dssdev);
290
291	omap_dss_put_device(in);
292
293	return 0;
294}
295
296static const struct of_device_id hdmic_of_match[] = {
297	{ .compatible = "omapdss,hdmi-connector", },
298	{},
299};
300
301MODULE_DEVICE_TABLE(of, hdmic_of_match);
302
303static struct platform_driver hdmi_connector_driver = {
304	.probe	= hdmic_probe,
305	.remove	= __exit_p(hdmic_remove),
306	.driver	= {
307		.name	= "connector-hdmi",
308		.of_match_table = hdmic_of_match,
309		.suppress_bind_attrs = true,
310	},
311};
312
313module_platform_driver(hdmi_connector_driver);
314
315MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
316MODULE_DESCRIPTION("HDMI Connector driver");
317MODULE_LICENSE("GPL");