Loading...
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");
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");