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 #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 
20 struct display_connector {
21 	struct drm_bridge	bridge;
22 
23 	struct gpio_desc	*hpd_gpio;
24 	int			hpd_irq;
25 
26 	struct regulator	*dp_pwr;
27 	struct gpio_desc	*ddc_en;
28 };
29 
30 static inline struct display_connector *
31 to_display_connector(struct drm_bridge *bridge)
32 {
33 	return container_of(bridge, struct display_connector, bridge);
34 }
35 
36 static 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 
42 static enum drm_connector_status
43 display_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 
84 static struct edid *display_connector_get_edid(struct drm_bridge *bridge,
85 					       struct drm_connector *connector)
86 {
87 	struct display_connector *conn = to_display_connector(bridge);
88 
89 	return drm_get_edid(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  */
99 static 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  */
141 static 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 
172 static const struct drm_bridge_funcs display_connector_bridge_funcs = {
173 	.attach = display_connector_attach,
174 	.detect = display_connector_detect,
175 	.get_edid = display_connector_get_edid,
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 
183 static 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 
193 static int display_connector_probe(struct platform_device *pdev)
194 {
195 	struct display_connector *conn;
196 	unsigned int type;
197 	const char *label = NULL;
198 	int ret;
199 
200 	conn = devm_kzalloc(&pdev->dev, sizeof(*conn), GFP_KERNEL);
201 	if (!conn)
202 		return -ENOMEM;
203 
204 	platform_set_drvdata(pdev, conn);
205 
206 	type = (uintptr_t)of_device_get_match_data(&pdev->dev);
207 
208 	/* Get the exact connector type. */
209 	switch (type) {
210 	case DRM_MODE_CONNECTOR_DVII: {
211 		bool analog, digital;
212 
213 		analog = of_property_read_bool(pdev->dev.of_node, "analog");
214 		digital = of_property_read_bool(pdev->dev.of_node, "digital");
215 		if (analog && !digital) {
216 			conn->bridge.type = DRM_MODE_CONNECTOR_DVIA;
217 		} else if (!analog && digital) {
218 			conn->bridge.type = DRM_MODE_CONNECTOR_DVID;
219 		} else if (analog && digital) {
220 			conn->bridge.type = DRM_MODE_CONNECTOR_DVII;
221 		} else {
222 			dev_err(&pdev->dev, "DVI connector with no type\n");
223 			return -EINVAL;
224 		}
225 		break;
226 	}
227 
228 	case DRM_MODE_CONNECTOR_HDMIA: {
229 		const char *hdmi_type;
230 
231 		ret = of_property_read_string(pdev->dev.of_node, "type",
232 					      &hdmi_type);
233 		if (ret < 0) {
234 			dev_err(&pdev->dev, "HDMI connector with no type\n");
235 			return -EINVAL;
236 		}
237 
238 		if (!strcmp(hdmi_type, "a") || !strcmp(hdmi_type, "c") ||
239 		    !strcmp(hdmi_type, "d") || !strcmp(hdmi_type, "e")) {
240 			conn->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
241 		} else if (!strcmp(hdmi_type, "b")) {
242 			conn->bridge.type = DRM_MODE_CONNECTOR_HDMIB;
243 		} else {
244 			dev_err(&pdev->dev,
245 				"Unsupported HDMI connector type '%s'\n",
246 				hdmi_type);
247 			return -EINVAL;
248 		}
249 
250 		break;
251 	}
252 
253 	default:
254 		conn->bridge.type = type;
255 		break;
256 	}
257 
258 	/* All the supported connector types support interlaced modes. */
259 	conn->bridge.interlace_allowed = true;
260 
261 	/* Get the optional connector label. */
262 	of_property_read_string(pdev->dev.of_node, "label", &label);
263 
264 	/*
265 	 * Get the HPD GPIO for DVI, HDMI and DP connectors. If the GPIO can provide
266 	 * edge interrupts, register an interrupt handler.
267 	 */
268 	if (type == DRM_MODE_CONNECTOR_DVII ||
269 	    type == DRM_MODE_CONNECTOR_HDMIA ||
270 	    type == DRM_MODE_CONNECTOR_DisplayPort) {
271 		conn->hpd_gpio = devm_gpiod_get_optional(&pdev->dev, "hpd",
272 							 GPIOD_IN);
273 		if (IS_ERR(conn->hpd_gpio)) {
274 			if (PTR_ERR(conn->hpd_gpio) != -EPROBE_DEFER)
275 				dev_err(&pdev->dev,
276 					"Unable to retrieve HPD GPIO\n");
277 			return PTR_ERR(conn->hpd_gpio);
278 		}
279 
280 		conn->hpd_irq = gpiod_to_irq(conn->hpd_gpio);
281 	} else {
282 		conn->hpd_irq = -EINVAL;
283 	}
284 
285 	if (conn->hpd_irq >= 0) {
286 		ret = devm_request_threaded_irq(&pdev->dev, conn->hpd_irq,
287 						NULL, display_connector_hpd_irq,
288 						IRQF_TRIGGER_RISING |
289 						IRQF_TRIGGER_FALLING |
290 						IRQF_ONESHOT,
291 						"HPD", conn);
292 		if (ret) {
293 			dev_info(&pdev->dev,
294 				 "Failed to request HPD edge interrupt, falling back to polling\n");
295 			conn->hpd_irq = -EINVAL;
296 		}
297 	}
298 
299 	/* Retrieve the DDC I2C adapter for DVI, HDMI and VGA connectors. */
300 	if (type == DRM_MODE_CONNECTOR_DVII ||
301 	    type == DRM_MODE_CONNECTOR_HDMIA ||
302 	    type == DRM_MODE_CONNECTOR_VGA) {
303 		struct device_node *phandle;
304 
305 		phandle = of_parse_phandle(pdev->dev.of_node, "ddc-i2c-bus", 0);
306 		if (phandle) {
307 			conn->bridge.ddc = of_get_i2c_adapter_by_node(phandle);
308 			of_node_put(phandle);
309 			if (!conn->bridge.ddc)
310 				return -EPROBE_DEFER;
311 		} else {
312 			dev_dbg(&pdev->dev,
313 				"No I2C bus specified, disabling EDID readout\n");
314 		}
315 	}
316 
317 	/* Get the DP PWR for DP connector. */
318 	if (type == DRM_MODE_CONNECTOR_DisplayPort) {
319 		int ret;
320 
321 		conn->dp_pwr = devm_regulator_get_optional(&pdev->dev, "dp-pwr");
322 
323 		if (IS_ERR(conn->dp_pwr)) {
324 			ret = PTR_ERR(conn->dp_pwr);
325 
326 			switch (ret) {
327 			case -ENODEV:
328 				conn->dp_pwr = NULL;
329 				break;
330 
331 			case -EPROBE_DEFER:
332 				return -EPROBE_DEFER;
333 
334 			default:
335 				dev_err(&pdev->dev, "failed to get DP PWR regulator: %d\n", ret);
336 				return ret;
337 			}
338 		}
339 
340 		if (conn->dp_pwr) {
341 			ret = regulator_enable(conn->dp_pwr);
342 			if (ret) {
343 				dev_err(&pdev->dev, "failed to enable DP PWR regulator: %d\n", ret);
344 				return ret;
345 			}
346 		}
347 	}
348 
349 	/* enable DDC */
350 	if (type == DRM_MODE_CONNECTOR_HDMIA) {
351 		conn->ddc_en = devm_gpiod_get_optional(&pdev->dev, "ddc-en",
352 						       GPIOD_OUT_HIGH);
353 
354 		if (IS_ERR(conn->ddc_en)) {
355 			dev_err(&pdev->dev, "Couldn't get ddc-en gpio\n");
356 			return PTR_ERR(conn->ddc_en);
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 
384 static int 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->dp_pwr)
392 		regulator_disable(conn->dp_pwr);
393 
394 	drm_bridge_remove(&conn->bridge);
395 
396 	if (!IS_ERR(conn->bridge.ddc))
397 		i2c_put_adapter(conn->bridge.ddc);
398 
399 	return 0;
400 }
401 
402 static const struct of_device_id display_connector_match[] = {
403 	{
404 		.compatible = "composite-video-connector",
405 		.data = (void *)DRM_MODE_CONNECTOR_Composite,
406 	}, {
407 		.compatible = "dvi-connector",
408 		.data = (void *)DRM_MODE_CONNECTOR_DVII,
409 	}, {
410 		.compatible = "hdmi-connector",
411 		.data = (void *)DRM_MODE_CONNECTOR_HDMIA,
412 	}, {
413 		.compatible = "svideo-connector",
414 		.data = (void *)DRM_MODE_CONNECTOR_SVIDEO,
415 	}, {
416 		.compatible = "vga-connector",
417 		.data = (void *)DRM_MODE_CONNECTOR_VGA,
418 	}, {
419 		.compatible = "dp-connector",
420 		.data = (void *)DRM_MODE_CONNECTOR_DisplayPort,
421 	},
422 	{},
423 };
424 MODULE_DEVICE_TABLE(of, display_connector_match);
425 
426 static struct platform_driver display_connector_driver = {
427 	.probe	= display_connector_probe,
428 	.remove	= display_connector_remove,
429 	.driver		= {
430 		.name		= "display-connector",
431 		.of_match_table	= display_connector_match,
432 	},
433 };
434 module_platform_driver(display_connector_driver);
435 
436 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
437 MODULE_DESCRIPTION("Display connector driver");
438 MODULE_LICENSE("GPL");
439