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 18 struct display_connector { 19 struct drm_bridge bridge; 20 21 struct gpio_desc *hpd_gpio; 22 int hpd_irq; 23 }; 24 25 static inline struct display_connector * 26 to_display_connector(struct drm_bridge *bridge) 27 { 28 return container_of(bridge, struct display_connector, bridge); 29 } 30 31 static 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 37 static enum drm_connector_status 38 display_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 79 static 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 87 static 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 93 static 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 103 static 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 250 static 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 262 static 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 }; 281 MODULE_DEVICE_TABLE(of, display_connector_match); 282 283 static 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 }; 291 module_platform_driver(display_connector_driver); 292 293 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>"); 294 MODULE_DESCRIPTION("Display connector driver"); 295 MODULE_LICENSE("GPL"); 296