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/media-bus-format.h>
10#include <linux/module.h>
11#include <linux/mutex.h>
12#include <linux/of.h>
13#include <linux/platform_device.h>
14#include <linux/regulator/consumer.h>
15
16#include <drm/drm_atomic_helper.h>
17#include <drm/drm_bridge.h>
18#include <drm/drm_edid.h>
19
20struct display_connector {
21	struct drm_bridge	bridge;
22
23	struct gpio_desc	*hpd_gpio;
24	int			hpd_irq;
25
26	struct regulator	*supply;
27	struct gpio_desc	*ddc_en;
28};
29
30static inline struct display_connector *
31to_display_connector(struct drm_bridge *bridge)
32{
33	return container_of(bridge, struct display_connector, bridge);
34}
35
36static int display_connector_attach(struct drm_bridge *bridge,
37				    enum drm_bridge_attach_flags flags)
38{
39	return flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR ? 0 : -EINVAL;
40}
41
42static enum drm_connector_status
43display_connector_detect(struct drm_bridge *bridge)
44{
45	struct display_connector *conn = to_display_connector(bridge);
46
47	if (conn->hpd_gpio) {
48		if (gpiod_get_value_cansleep(conn->hpd_gpio))
49			return connector_status_connected;
50		else
51			return connector_status_disconnected;
52	}
53
54	if (conn->bridge.ddc && drm_probe_ddc(conn->bridge.ddc))
55		return connector_status_connected;
56
57	switch (conn->bridge.type) {
58	case DRM_MODE_CONNECTOR_DVIA:
59	case DRM_MODE_CONNECTOR_DVID:
60	case DRM_MODE_CONNECTOR_DVII:
61	case DRM_MODE_CONNECTOR_HDMIA:
62	case DRM_MODE_CONNECTOR_HDMIB:
63		/*
64		 * For DVI and HDMI connectors a DDC probe failure indicates
65		 * that no cable is connected.
66		 */
67		return connector_status_disconnected;
68
69	case DRM_MODE_CONNECTOR_Composite:
70	case DRM_MODE_CONNECTOR_SVIDEO:
71	case DRM_MODE_CONNECTOR_VGA:
72	default:
73		/*
74		 * Composite and S-Video connectors have no other detection
75		 * mean than the HPD GPIO. For VGA connectors, even if we have
76		 * an I2C bus, we can't assume that the cable is disconnected
77		 * if drm_probe_ddc fails, as some cables don't wire the DDC
78		 * pins.
79		 */
80		return connector_status_unknown;
81	}
82}
83
84static const struct drm_edid *display_connector_edid_read(struct drm_bridge *bridge,
85							  struct drm_connector *connector)
86{
87	struct display_connector *conn = to_display_connector(bridge);
88
89	return drm_edid_read_ddc(connector, conn->bridge.ddc);
90}
91
92/*
93 * Since this bridge is tied to the connector, it acts like a passthrough,
94 * so concerning the output bus formats, either pass the bus formats from the
95 * previous bridge or return fallback data like done in the bridge function:
96 * drm_atomic_bridge_chain_select_bus_fmts().
97 * This supports negotiation if the bridge chain has all bits in place.
98 */
99static u32 *display_connector_get_output_bus_fmts(struct drm_bridge *bridge,
100					struct drm_bridge_state *bridge_state,
101					struct drm_crtc_state *crtc_state,
102					struct drm_connector_state *conn_state,
103					unsigned int *num_output_fmts)
104{
105	struct drm_bridge *prev_bridge = drm_bridge_get_prev_bridge(bridge);
106	struct drm_bridge_state *prev_bridge_state;
107
108	if (!prev_bridge || !prev_bridge->funcs->atomic_get_output_bus_fmts) {
109		struct drm_connector *conn = conn_state->connector;
110		u32 *out_bus_fmts;
111
112		*num_output_fmts = 1;
113		out_bus_fmts = kmalloc(sizeof(*out_bus_fmts), GFP_KERNEL);
114		if (!out_bus_fmts)
115			return NULL;
116
117		if (conn->display_info.num_bus_formats &&
118		    conn->display_info.bus_formats)
119			out_bus_fmts[0] = conn->display_info.bus_formats[0];
120		else
121			out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED;
122
123		return out_bus_fmts;
124	}
125
126	prev_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
127							    prev_bridge);
128
129	return prev_bridge->funcs->atomic_get_output_bus_fmts(prev_bridge, prev_bridge_state,
130							      crtc_state, conn_state,
131							      num_output_fmts);
132}
133
134/*
135 * Since this bridge is tied to the connector, it acts like a passthrough,
136 * so concerning the input bus formats, either pass the bus formats from the
137 * previous bridge or MEDIA_BUS_FMT_FIXED (like select_bus_fmt_recursive())
138 * when atomic_get_input_bus_fmts is not supported.
139 * This supports negotiation if the bridge chain has all bits in place.
140 */
141static u32 *display_connector_get_input_bus_fmts(struct drm_bridge *bridge,
142					struct drm_bridge_state *bridge_state,
143					struct drm_crtc_state *crtc_state,
144					struct drm_connector_state *conn_state,
145					u32 output_fmt,
146					unsigned int *num_input_fmts)
147{
148	struct drm_bridge *prev_bridge = drm_bridge_get_prev_bridge(bridge);
149	struct drm_bridge_state *prev_bridge_state;
150
151	if (!prev_bridge || !prev_bridge->funcs->atomic_get_input_bus_fmts) {
152		u32 *in_bus_fmts;
153
154		*num_input_fmts = 1;
155		in_bus_fmts = kmalloc(sizeof(*in_bus_fmts), GFP_KERNEL);
156		if (!in_bus_fmts)
157			return NULL;
158
159		in_bus_fmts[0] = MEDIA_BUS_FMT_FIXED;
160
161		return in_bus_fmts;
162	}
163
164	prev_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
165							    prev_bridge);
166
167	return prev_bridge->funcs->atomic_get_input_bus_fmts(prev_bridge, prev_bridge_state,
168							     crtc_state, conn_state, output_fmt,
169							     num_input_fmts);
170}
171
172static const struct drm_bridge_funcs display_connector_bridge_funcs = {
173	.attach = display_connector_attach,
174	.detect = display_connector_detect,
175	.edid_read = display_connector_edid_read,
176	.atomic_get_output_bus_fmts = display_connector_get_output_bus_fmts,
177	.atomic_get_input_bus_fmts = display_connector_get_input_bus_fmts,
178	.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
179	.atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
180	.atomic_reset = drm_atomic_helper_bridge_reset,
181};
182
183static irqreturn_t display_connector_hpd_irq(int irq, void *arg)
184{
185	struct display_connector *conn = arg;
186	struct drm_bridge *bridge = &conn->bridge;
187
188	drm_bridge_hpd_notify(bridge, display_connector_detect(bridge));
189
190	return IRQ_HANDLED;
191}
192
193static int display_connector_get_supply(struct platform_device *pdev,
194					struct display_connector *conn,
195					const char *name)
196{
197	conn->supply = devm_regulator_get_optional(&pdev->dev, name);
198
199	if (conn->supply == ERR_PTR(-ENODEV))
200		conn->supply = NULL;
201
202	return PTR_ERR_OR_ZERO(conn->supply);
203}
204
205static int display_connector_probe(struct platform_device *pdev)
206{
207	struct display_connector *conn;
208	unsigned int type;
209	const char *label = NULL;
210	int ret;
211
212	conn = devm_kzalloc(&pdev->dev, sizeof(*conn), GFP_KERNEL);
213	if (!conn)
214		return -ENOMEM;
215
216	platform_set_drvdata(pdev, conn);
217
218	type = (uintptr_t)of_device_get_match_data(&pdev->dev);
219
220	/* Get the exact connector type. */
221	switch (type) {
222	case DRM_MODE_CONNECTOR_DVII: {
223		bool analog, digital;
224
225		analog = of_property_read_bool(pdev->dev.of_node, "analog");
226		digital = of_property_read_bool(pdev->dev.of_node, "digital");
227		if (analog && !digital) {
228			conn->bridge.type = DRM_MODE_CONNECTOR_DVIA;
229		} else if (!analog && digital) {
230			conn->bridge.type = DRM_MODE_CONNECTOR_DVID;
231		} else if (analog && digital) {
232			conn->bridge.type = DRM_MODE_CONNECTOR_DVII;
233		} else {
234			dev_err(&pdev->dev, "DVI connector with no type\n");
235			return -EINVAL;
236		}
237		break;
238	}
239
240	case DRM_MODE_CONNECTOR_HDMIA: {
241		const char *hdmi_type;
242
243		ret = of_property_read_string(pdev->dev.of_node, "type",
244					      &hdmi_type);
245		if (ret < 0) {
246			dev_err(&pdev->dev, "HDMI connector with no type\n");
247			return -EINVAL;
248		}
249
250		if (!strcmp(hdmi_type, "a") || !strcmp(hdmi_type, "c") ||
251		    !strcmp(hdmi_type, "d") || !strcmp(hdmi_type, "e")) {
252			conn->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
253		} else if (!strcmp(hdmi_type, "b")) {
254			conn->bridge.type = DRM_MODE_CONNECTOR_HDMIB;
255		} else {
256			dev_err(&pdev->dev,
257				"Unsupported HDMI connector type '%s'\n",
258				hdmi_type);
259			return -EINVAL;
260		}
261
262		break;
263	}
264
265	default:
266		conn->bridge.type = type;
267		break;
268	}
269
270	/* All the supported connector types support interlaced modes. */
271	conn->bridge.interlace_allowed = true;
272
273	/* Get the optional connector label. */
274	of_property_read_string(pdev->dev.of_node, "label", &label);
275
276	/*
277	 * Get the HPD GPIO for DVI, HDMI and DP connectors. If the GPIO can provide
278	 * edge interrupts, register an interrupt handler.
279	 */
280	if (type == DRM_MODE_CONNECTOR_DVII ||
281	    type == DRM_MODE_CONNECTOR_HDMIA ||
282	    type == DRM_MODE_CONNECTOR_DisplayPort) {
283		conn->hpd_gpio = devm_gpiod_get_optional(&pdev->dev, "hpd",
284							 GPIOD_IN);
285		if (IS_ERR(conn->hpd_gpio))
286			return dev_err_probe(&pdev->dev, PTR_ERR(conn->hpd_gpio),
287					     "Unable to retrieve HPD GPIO\n");
288
289		conn->hpd_irq = gpiod_to_irq(conn->hpd_gpio);
290	} else {
291		conn->hpd_irq = -EINVAL;
292	}
293
294	if (conn->hpd_irq >= 0) {
295		ret = devm_request_threaded_irq(&pdev->dev, conn->hpd_irq,
296						NULL, display_connector_hpd_irq,
297						IRQF_TRIGGER_RISING |
298						IRQF_TRIGGER_FALLING |
299						IRQF_ONESHOT,
300						"HPD", conn);
301		if (ret) {
302			dev_info(&pdev->dev,
303				 "Failed to request HPD edge interrupt, falling back to polling\n");
304			conn->hpd_irq = -EINVAL;
305		}
306	}
307
308	/* Retrieve the DDC I2C adapter for DVI, HDMI and VGA connectors. */
309	if (type == DRM_MODE_CONNECTOR_DVII ||
310	    type == DRM_MODE_CONNECTOR_HDMIA ||
311	    type == DRM_MODE_CONNECTOR_VGA) {
312		struct device_node *phandle;
313
314		phandle = of_parse_phandle(pdev->dev.of_node, "ddc-i2c-bus", 0);
315		if (phandle) {
316			conn->bridge.ddc = of_get_i2c_adapter_by_node(phandle);
317			of_node_put(phandle);
318			if (!conn->bridge.ddc)
319				return -EPROBE_DEFER;
320		} else {
321			dev_dbg(&pdev->dev,
322				"No I2C bus specified, disabling EDID readout\n");
323		}
324	}
325
326	/* Get the DP PWR for DP connector. */
327	if (type == DRM_MODE_CONNECTOR_DisplayPort) {
328		int ret;
329
330		ret = display_connector_get_supply(pdev, conn, "dp-pwr");
331		if (ret < 0)
332			return dev_err_probe(&pdev->dev, ret, "failed to get DP PWR regulator\n");
333	}
334
335	/* enable DDC */
336	if (type == DRM_MODE_CONNECTOR_HDMIA) {
337		int ret;
338
339		conn->ddc_en = devm_gpiod_get_optional(&pdev->dev, "ddc-en",
340						       GPIOD_OUT_HIGH);
341
342		if (IS_ERR(conn->ddc_en)) {
343			dev_err(&pdev->dev, "Couldn't get ddc-en gpio\n");
344			return PTR_ERR(conn->ddc_en);
345		}
346
347		ret = display_connector_get_supply(pdev, conn, "hdmi-pwr");
348		if (ret < 0)
349			return dev_err_probe(&pdev->dev, ret, "failed to get HDMI +5V Power regulator\n");
350	}
351
352	if (conn->supply) {
353		ret = regulator_enable(conn->supply);
354		if (ret) {
355			dev_err(&pdev->dev, "failed to enable PWR regulator: %d\n", ret);
356			return ret;
357		}
358	}
359
360	conn->bridge.funcs = &display_connector_bridge_funcs;
361	conn->bridge.of_node = pdev->dev.of_node;
362
363	if (conn->bridge.ddc)
364		conn->bridge.ops |= DRM_BRIDGE_OP_EDID
365				 |  DRM_BRIDGE_OP_DETECT;
366	if (conn->hpd_gpio)
367		conn->bridge.ops |= DRM_BRIDGE_OP_DETECT;
368	if (conn->hpd_irq >= 0)
369		conn->bridge.ops |= DRM_BRIDGE_OP_HPD;
370
371	dev_dbg(&pdev->dev,
372		"Found %s display connector '%s' %s DDC bus and %s HPD GPIO (ops 0x%x)\n",
373		drm_get_connector_type_name(conn->bridge.type),
374		label ? label : "<unlabelled>",
375		conn->bridge.ddc ? "with" : "without",
376		conn->hpd_gpio ? "with" : "without",
377		conn->bridge.ops);
378
379	drm_bridge_add(&conn->bridge);
380
381	return 0;
382}
383
384static void display_connector_remove(struct platform_device *pdev)
385{
386	struct display_connector *conn = platform_get_drvdata(pdev);
387
388	if (conn->ddc_en)
389		gpiod_set_value(conn->ddc_en, 0);
390
391	if (conn->supply)
392		regulator_disable(conn->supply);
393
394	drm_bridge_remove(&conn->bridge);
395
396	if (!IS_ERR(conn->bridge.ddc))
397		i2c_put_adapter(conn->bridge.ddc);
398}
399
400static const struct of_device_id display_connector_match[] = {
401	{
402		.compatible = "composite-video-connector",
403		.data = (void *)DRM_MODE_CONNECTOR_Composite,
404	}, {
405		.compatible = "dvi-connector",
406		.data = (void *)DRM_MODE_CONNECTOR_DVII,
407	}, {
408		.compatible = "hdmi-connector",
409		.data = (void *)DRM_MODE_CONNECTOR_HDMIA,
410	}, {
411		.compatible = "svideo-connector",
412		.data = (void *)DRM_MODE_CONNECTOR_SVIDEO,
413	}, {
414		.compatible = "vga-connector",
415		.data = (void *)DRM_MODE_CONNECTOR_VGA,
416	}, {
417		.compatible = "dp-connector",
418		.data = (void *)DRM_MODE_CONNECTOR_DisplayPort,
419	},
420	{},
421};
422MODULE_DEVICE_TABLE(of, display_connector_match);
423
424static struct platform_driver display_connector_driver = {
425	.probe	= display_connector_probe,
426	.remove_new = display_connector_remove,
427	.driver		= {
428		.name		= "display-connector",
429		.of_match_table	= display_connector_match,
430	},
431};
432module_platform_driver(display_connector_driver);
433
434MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
435MODULE_DESCRIPTION("Display connector driver");
436MODULE_LICENSE("GPL");
437