1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2019 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
6 #include <linux/gpio/consumer.h>
8 #include <linux/interrupt.h>
9 #include <linux/module.h>
10 #include <linux/mutex.h>
12 #include <linux/of_device.h>
13 #include <linux/platform_device.h>
14 #include <linux/regulator/consumer.h>
16 #include <drm/drm_atomic_helper.h>
17 #include <drm/drm_bridge.h>
18 #include <drm/drm_edid.h>
20 struct display_connector {
21 struct drm_bridge bridge;
23 struct gpio_desc *hpd_gpio;
26 struct regulator *dp_pwr;
27 struct gpio_desc *ddc_en;
30 static inline struct display_connector *
31 to_display_connector(struct drm_bridge *bridge)
33 return container_of(bridge, struct display_connector, bridge);
36 static int display_connector_attach(struct drm_bridge *bridge,
37 enum drm_bridge_attach_flags flags)
39 return flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR ? 0 : -EINVAL;
42 static enum drm_connector_status
43 display_connector_detect(struct drm_bridge *bridge)
45 struct display_connector *conn = to_display_connector(bridge);
48 if (gpiod_get_value_cansleep(conn->hpd_gpio))
49 return connector_status_connected;
51 return connector_status_disconnected;
54 if (conn->bridge.ddc && drm_probe_ddc(conn->bridge.ddc))
55 return connector_status_connected;
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:
64 * For DVI and HDMI connectors a DDC probe failure indicates
65 * that no cable is connected.
67 return connector_status_disconnected;
69 case DRM_MODE_CONNECTOR_Composite:
70 case DRM_MODE_CONNECTOR_SVIDEO:
71 case DRM_MODE_CONNECTOR_VGA:
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
80 return connector_status_unknown;
84 static struct edid *display_connector_get_edid(struct drm_bridge *bridge,
85 struct drm_connector *connector)
87 struct display_connector *conn = to_display_connector(bridge);
89 return drm_get_edid(connector, conn->bridge.ddc);
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.
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)
105 struct drm_bridge *prev_bridge = drm_bridge_get_prev_bridge(bridge);
106 struct drm_bridge_state *prev_bridge_state;
108 if (!prev_bridge || !prev_bridge->funcs->atomic_get_output_bus_fmts) {
109 struct drm_connector *conn = conn_state->connector;
112 *num_output_fmts = 1;
113 out_bus_fmts = kmalloc(sizeof(*out_bus_fmts), GFP_KERNEL);
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];
121 out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED;
126 prev_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
129 return prev_bridge->funcs->atomic_get_output_bus_fmts(prev_bridge, prev_bridge_state,
130 crtc_state, conn_state,
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.
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,
146 unsigned int *num_input_fmts)
148 struct drm_bridge *prev_bridge = drm_bridge_get_prev_bridge(bridge);
149 struct drm_bridge_state *prev_bridge_state;
151 if (!prev_bridge || !prev_bridge->funcs->atomic_get_input_bus_fmts) {
155 in_bus_fmts = kmalloc(sizeof(*in_bus_fmts), GFP_KERNEL);
159 in_bus_fmts[0] = MEDIA_BUS_FMT_FIXED;
164 prev_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
167 return prev_bridge->funcs->atomic_get_input_bus_fmts(prev_bridge, prev_bridge_state,
168 crtc_state, conn_state, output_fmt,
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,
183 static irqreturn_t display_connector_hpd_irq(int irq, void *arg)
185 struct display_connector *conn = arg;
186 struct drm_bridge *bridge = &conn->bridge;
188 drm_bridge_hpd_notify(bridge, display_connector_detect(bridge));
193 static int display_connector_probe(struct platform_device *pdev)
195 struct display_connector *conn;
197 const char *label = NULL;
200 conn = devm_kzalloc(&pdev->dev, sizeof(*conn), GFP_KERNEL);
204 platform_set_drvdata(pdev, conn);
206 type = (uintptr_t)of_device_get_match_data(&pdev->dev);
208 /* Get the exact connector type. */
210 case DRM_MODE_CONNECTOR_DVII: {
211 bool analog, digital;
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;
222 dev_err(&pdev->dev, "DVI connector with no type\n");
228 case DRM_MODE_CONNECTOR_HDMIA: {
229 const char *hdmi_type;
231 ret = of_property_read_string(pdev->dev.of_node, "type",
234 dev_err(&pdev->dev, "HDMI connector with no type\n");
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;
245 "Unsupported HDMI connector type '%s'\n",
254 conn->bridge.type = type;
258 /* All the supported connector types support interlaced modes. */
259 conn->bridge.interlace_allowed = true;
261 /* Get the optional connector label. */
262 of_property_read_string(pdev->dev.of_node, "label", &label);
265 * Get the HPD GPIO for DVI, HDMI and DP connectors. If the GPIO can provide
266 * edge interrupts, register an interrupt handler.
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",
273 if (IS_ERR(conn->hpd_gpio)) {
274 if (PTR_ERR(conn->hpd_gpio) != -EPROBE_DEFER)
276 "Unable to retrieve HPD GPIO\n");
277 return PTR_ERR(conn->hpd_gpio);
280 conn->hpd_irq = gpiod_to_irq(conn->hpd_gpio);
282 conn->hpd_irq = -EINVAL;
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 |
294 "Failed to request HPD edge interrupt, falling back to polling\n");
295 conn->hpd_irq = -EINVAL;
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;
305 phandle = of_parse_phandle(pdev->dev.of_node, "ddc-i2c-bus", 0);
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;
313 "No I2C bus specified, disabling EDID readout\n");
317 /* Get the DP PWR for DP connector. */
318 if (type == DRM_MODE_CONNECTOR_DisplayPort) {
321 conn->dp_pwr = devm_regulator_get_optional(&pdev->dev, "dp-pwr");
323 if (IS_ERR(conn->dp_pwr)) {
324 ret = PTR_ERR(conn->dp_pwr);
332 return -EPROBE_DEFER;
335 dev_err(&pdev->dev, "failed to get DP PWR regulator: %d\n", ret);
341 ret = regulator_enable(conn->dp_pwr);
343 dev_err(&pdev->dev, "failed to enable DP PWR regulator: %d\n", ret);
350 if (type == DRM_MODE_CONNECTOR_HDMIA) {
351 conn->ddc_en = devm_gpiod_get_optional(&pdev->dev, "ddc-en",
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);
360 conn->bridge.funcs = &display_connector_bridge_funcs;
361 conn->bridge.of_node = pdev->dev.of_node;
363 if (conn->bridge.ddc)
364 conn->bridge.ops |= DRM_BRIDGE_OP_EDID
365 | DRM_BRIDGE_OP_DETECT;
367 conn->bridge.ops |= DRM_BRIDGE_OP_DETECT;
368 if (conn->hpd_irq >= 0)
369 conn->bridge.ops |= DRM_BRIDGE_OP_HPD;
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",
379 drm_bridge_add(&conn->bridge);
384 static int display_connector_remove(struct platform_device *pdev)
386 struct display_connector *conn = platform_get_drvdata(pdev);
389 gpiod_set_value(conn->ddc_en, 0);
392 regulator_disable(conn->dp_pwr);
394 drm_bridge_remove(&conn->bridge);
396 if (!IS_ERR(conn->bridge.ddc))
397 i2c_put_adapter(conn->bridge.ddc);
402 static const struct of_device_id display_connector_match[] = {
404 .compatible = "composite-video-connector",
405 .data = (void *)DRM_MODE_CONNECTOR_Composite,
407 .compatible = "dvi-connector",
408 .data = (void *)DRM_MODE_CONNECTOR_DVII,
410 .compatible = "hdmi-connector",
411 .data = (void *)DRM_MODE_CONNECTOR_HDMIA,
413 .compatible = "svideo-connector",
414 .data = (void *)DRM_MODE_CONNECTOR_SVIDEO,
416 .compatible = "vga-connector",
417 .data = (void *)DRM_MODE_CONNECTOR_VGA,
419 .compatible = "dp-connector",
420 .data = (void *)DRM_MODE_CONNECTOR_DisplayPort,
424 MODULE_DEVICE_TABLE(of, display_connector_match);
426 static struct platform_driver display_connector_driver = {
427 .probe = display_connector_probe,
428 .remove = display_connector_remove,
430 .name = "display-connector",
431 .of_match_table = display_connector_match,
434 module_platform_driver(display_connector_driver);
436 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
437 MODULE_DESCRIPTION("Display connector driver");
438 MODULE_LICENSE("GPL");