drivers/gpu/drm/bridge/display-connector.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2019 Laurent Pinchart <[email protected]>
   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 <[email protected]>");
 294 MODULE_DESCRIPTION("Display connector driver");
 295 MODULE_LICENSE("GPL");