1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 2019 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
  4 */
  5
  6#include <linux/gpio/consumer.h>
  7#include <linux/i2c.h>
  8#include <linux/interrupt.h>
  9#include <linux/module.h>
 10#include <linux/mutex.h>
 11#include <linux/of.h>
 12#include <linux/of_device.h>
 13#include <linux/platform_device.h>
 14
 15#include <drm/drm_bridge.h>
 16#include <drm/drm_edid.h>
 17
 18struct display_connector {
 19	struct drm_bridge	bridge;
 20
 21	struct gpio_desc	*hpd_gpio;
 22	int			hpd_irq;
 23};
 24
 25static inline struct display_connector *
 26to_display_connector(struct drm_bridge *bridge)
 27{
 28	return container_of(bridge, struct display_connector, bridge);
 29}
 30
 31static int display_connector_attach(struct drm_bridge *bridge,
 32				    enum drm_bridge_attach_flags flags)
 33{
 34	return flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR ? 0 : -EINVAL;
 35}
 36
 37static enum drm_connector_status
 38display_connector_detect(struct drm_bridge *bridge)
 39{
 40	struct display_connector *conn = to_display_connector(bridge);
 41
 42	if (conn->hpd_gpio) {
 43		if (gpiod_get_value_cansleep(conn->hpd_gpio))
 44			return connector_status_connected;
 45		else
 46			return connector_status_disconnected;
 47	}
 48
 49	if (conn->bridge.ddc && drm_probe_ddc(conn->bridge.ddc))
 50		return connector_status_connected;
 51
 52	switch (conn->bridge.type) {
 53	case DRM_MODE_CONNECTOR_DVIA:
 54	case DRM_MODE_CONNECTOR_DVID:
 55	case DRM_MODE_CONNECTOR_DVII:
 56	case DRM_MODE_CONNECTOR_HDMIA:
 57	case DRM_MODE_CONNECTOR_HDMIB:
 58		/*
 59		 * For DVI and HDMI connectors a DDC probe failure indicates
 60		 * that no cable is connected.
 61		 */
 62		return connector_status_disconnected;
 63
 64	case DRM_MODE_CONNECTOR_Composite:
 65	case DRM_MODE_CONNECTOR_SVIDEO:
 66	case DRM_MODE_CONNECTOR_VGA:
 67	default:
 68		/*
 69		 * Composite and S-Video connectors have no other detection
 70		 * mean than the HPD GPIO. For VGA connectors, even if we have
 71		 * an I2C bus, we can't assume that the cable is disconnected
 72		 * if drm_probe_ddc fails, as some cables don't wire the DDC
 73		 * pins.
 74		 */
 75		return connector_status_unknown;
 76	}
 77}
 78
 79static struct edid *display_connector_get_edid(struct drm_bridge *bridge,
 80					       struct drm_connector *connector)
 81{
 82	struct display_connector *conn = to_display_connector(bridge);
 83
 84	return drm_get_edid(connector, conn->bridge.ddc);
 85}
 86
 87static const struct drm_bridge_funcs display_connector_bridge_funcs = {
 88	.attach = display_connector_attach,
 89	.detect = display_connector_detect,
 90	.get_edid = display_connector_get_edid,
 91};
 92
 93static irqreturn_t display_connector_hpd_irq(int irq, void *arg)
 94{
 95	struct display_connector *conn = arg;
 96	struct drm_bridge *bridge = &conn->bridge;
 97
 98	drm_bridge_hpd_notify(bridge, display_connector_detect(bridge));
 99
100	return IRQ_HANDLED;
101}
102
103static int display_connector_probe(struct platform_device *pdev)
104{
105	struct display_connector *conn;
106	unsigned int type;
107	const char *label;
108	int ret;
109
110	conn = devm_kzalloc(&pdev->dev, sizeof(*conn), GFP_KERNEL);
111	if (!conn)
112		return -ENOMEM;
113
114	platform_set_drvdata(pdev, conn);
115
116	type = (uintptr_t)of_device_get_match_data(&pdev->dev);
117
118	/* Get the exact connector type. */
119	switch (type) {
120	case DRM_MODE_CONNECTOR_DVII: {
121		bool analog, digital;
122
123		analog = of_property_read_bool(pdev->dev.of_node, "analog");
124		digital = of_property_read_bool(pdev->dev.of_node, "digital");
125		if (analog && !digital) {
126			conn->bridge.type = DRM_MODE_CONNECTOR_DVIA;
127		} else if (!analog && digital) {
128			conn->bridge.type = DRM_MODE_CONNECTOR_DVID;
129		} else if (analog && digital) {
130			conn->bridge.type = DRM_MODE_CONNECTOR_DVII;
131		} else {
132			dev_err(&pdev->dev, "DVI connector with no type\n");
133			return -EINVAL;
134		}
135		break;
136	}
137
138	case DRM_MODE_CONNECTOR_HDMIA: {
139		const char *hdmi_type;
140
141		ret = of_property_read_string(pdev->dev.of_node, "type",
142					      &hdmi_type);
143		if (ret < 0) {
144			dev_err(&pdev->dev, "HDMI connector with no type\n");
145			return -EINVAL;
146		}
147
148		if (!strcmp(hdmi_type, "a") || !strcmp(hdmi_type, "c") ||
149		    !strcmp(hdmi_type, "d") || !strcmp(hdmi_type, "e")) {
150			conn->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
151		} else if (!strcmp(hdmi_type, "b")) {
152			conn->bridge.type = DRM_MODE_CONNECTOR_HDMIB;
153		} else {
154			dev_err(&pdev->dev,
155				"Unsupported HDMI connector type '%s'\n",
156				hdmi_type);
157			return -EINVAL;
158		}
159
160		break;
161	}
162
163	default:
164		conn->bridge.type = type;
165		break;
166	}
167
168	/* All the supported connector types support interlaced modes. */
169	conn->bridge.interlace_allowed = true;
170
171	/* Get the optional connector label. */
172	of_property_read_string(pdev->dev.of_node, "label", &label);
173
174	/*
175	 * Get the HPD GPIO for DVI and HDMI connectors. If the GPIO can provide
176	 * edge interrupts, register an interrupt handler.
177	 */
178	if (type == DRM_MODE_CONNECTOR_DVII ||
179	    type == DRM_MODE_CONNECTOR_HDMIA) {
180		conn->hpd_gpio = devm_gpiod_get_optional(&pdev->dev, "hpd",
181							 GPIOD_IN);
182		if (IS_ERR(conn->hpd_gpio)) {
183			if (PTR_ERR(conn->hpd_gpio) != -EPROBE_DEFER)
184				dev_err(&pdev->dev,
185					"Unable to retrieve HPD GPIO\n");
186			return PTR_ERR(conn->hpd_gpio);
187		}
188
189		conn->hpd_irq = gpiod_to_irq(conn->hpd_gpio);
190	} else {
191		conn->hpd_irq = -EINVAL;
192	}
193
194	if (conn->hpd_irq >= 0) {
195		ret = devm_request_threaded_irq(&pdev->dev, conn->hpd_irq,
196						NULL, display_connector_hpd_irq,
197						IRQF_TRIGGER_RISING |
198						IRQF_TRIGGER_FALLING |
199						IRQF_ONESHOT,
200						"HPD", conn);
201		if (ret) {
202			dev_info(&pdev->dev,
203				 "Failed to request HPD edge interrupt, falling back to polling\n");
204			conn->hpd_irq = -EINVAL;
205		}
206	}
207
208	/* Retrieve the DDC I2C adapter for DVI, HDMI and VGA connectors. */
209	if (type == DRM_MODE_CONNECTOR_DVII ||
210	    type == DRM_MODE_CONNECTOR_HDMIA ||
211	    type == DRM_MODE_CONNECTOR_VGA) {
212		struct device_node *phandle;
213
214		phandle = of_parse_phandle(pdev->dev.of_node, "ddc-i2c-bus", 0);
215		if (phandle) {
216			conn->bridge.ddc = of_get_i2c_adapter_by_node(phandle);
217			of_node_put(phandle);
218			if (!conn->bridge.ddc)
219				return -EPROBE_DEFER;
220		} else {
221			dev_dbg(&pdev->dev,
222				"No I2C bus specified, disabling EDID readout\n");
223		}
224	}
225
226	conn->bridge.funcs = &display_connector_bridge_funcs;
227	conn->bridge.of_node = pdev->dev.of_node;
228
229	if (conn->bridge.ddc)
230		conn->bridge.ops |= DRM_BRIDGE_OP_EDID
231				 |  DRM_BRIDGE_OP_DETECT;
232	if (conn->hpd_gpio)
233		conn->bridge.ops |= DRM_BRIDGE_OP_DETECT;
234	if (conn->hpd_irq >= 0)
235		conn->bridge.ops |= DRM_BRIDGE_OP_HPD;
236
237	dev_dbg(&pdev->dev,
238		"Found %s display connector '%s' %s DDC bus and %s HPD GPIO (ops 0x%x)\n",
239		drm_get_connector_type_name(conn->bridge.type),
240		label ? label : "<unlabelled>",
241		conn->bridge.ddc ? "with" : "without",
242		conn->hpd_gpio ? "with" : "without",
243		conn->bridge.ops);
244
245	drm_bridge_add(&conn->bridge);
246
247	return 0;
248}
249
250static int display_connector_remove(struct platform_device *pdev)
251{
252	struct display_connector *conn = platform_get_drvdata(pdev);
253
254	drm_bridge_remove(&conn->bridge);
255
256	if (!IS_ERR(conn->bridge.ddc))
257		i2c_put_adapter(conn->bridge.ddc);
258
259	return 0;
260}
261
262static const struct of_device_id display_connector_match[] = {
263	{
264		.compatible = "composite-video-connector",
265		.data = (void *)DRM_MODE_CONNECTOR_Composite,
266	}, {
267		.compatible = "dvi-connector",
268		.data = (void *)DRM_MODE_CONNECTOR_DVII,
269	}, {
270		.compatible = "hdmi-connector",
271		.data = (void *)DRM_MODE_CONNECTOR_HDMIA,
272	}, {
273		.compatible = "svideo-connector",
274		.data = (void *)DRM_MODE_CONNECTOR_SVIDEO,
275	}, {
276		.compatible = "vga-connector",
277		.data = (void *)DRM_MODE_CONNECTOR_VGA,
278	},
279	{},
280};
281MODULE_DEVICE_TABLE(of, display_connector_match);
282
283static struct platform_driver display_connector_driver = {
284	.probe	= display_connector_probe,
285	.remove	= display_connector_remove,
286	.driver		= {
287		.name		= "display-connector",
288		.of_match_table	= display_connector_match,
289	},
290};
291module_platform_driver(display_connector_driver);
292
293MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
294MODULE_DESCRIPTION("Display connector driver");
295MODULE_LICENSE("GPL");