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/media-bus-format.h>
  10 #include <linux/module.h>
  11 #include <linux/mutex.h>
  12 #include <linux/of.h>
  13 #include <linux/of_device.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/regulator/consumer.h>
  16
  17 #include <drm/drm_atomic_helper.h>
  18 #include <drm/drm_bridge.h>
  19 #include <drm/drm_edid.h>
  20
  21 struct display_connector {
  22         struct drm_bridge       bridge;
  23
  24         struct gpio_desc        *hpd_gpio;
  25         int                     hpd_irq;
  26
  27         struct regulator        *dp_pwr;
  28         struct gpio_desc        *ddc_en;
  29 };
  30
  31 static inline struct display_connector *
  32 to_display_connector(struct drm_bridge *bridge)
  33 {
  34         return container_of(bridge, struct display_connector, bridge);
  35 }
  36
  37 static int display_connector_attach(struct drm_bridge *bridge,
  38                                     enum drm_bridge_attach_flags flags)
  39 {
  40         return flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR ? 0 : -EINVAL;
  41 }
  42
  43 static enum drm_connector_status
  44 display_connector_detect(struct drm_bridge *bridge)
  45 {
  46         struct display_connector *conn = to_display_connector(bridge);
  47
  48         if (conn->hpd_gpio) {
  49                 if (gpiod_get_value_cansleep(conn->hpd_gpio))
  50                         return connector_status_connected;
  51                 else
  52                         return connector_status_disconnected;
  53         }
  54
  55         if (conn->bridge.ddc && drm_probe_ddc(conn->bridge.ddc))
  56                 return connector_status_connected;
  57
  58         switch (conn->bridge.type) {
  59         case DRM_MODE_CONNECTOR_DVIA:
  60         case DRM_MODE_CONNECTOR_DVID:
  61         case DRM_MODE_CONNECTOR_DVII:
  62         case DRM_MODE_CONNECTOR_HDMIA:
  63         case DRM_MODE_CONNECTOR_HDMIB:
  64                 /*
  65                  * For DVI and HDMI connectors a DDC probe failure indicates
  66                  * that no cable is connected.
  67                  */
  68                 return connector_status_disconnected;
  69
  70         case DRM_MODE_CONNECTOR_Composite:
  71         case DRM_MODE_CONNECTOR_SVIDEO:
  72         case DRM_MODE_CONNECTOR_VGA:
  73         default:
  74                 /*
  75                  * Composite and S-Video connectors have no other detection
  76                  * mean than the HPD GPIO. For VGA connectors, even if we have
  77                  * an I2C bus, we can't assume that the cable is disconnected
  78                  * if drm_probe_ddc fails, as some cables don't wire the DDC
  79                  * pins.
  80                  */
  81                 return connector_status_unknown;
  82         }
  83 }
  84
  85 static struct edid *display_connector_get_edid(struct drm_bridge *bridge,
  86                                                struct drm_connector *connector)
  87 {
  88         struct display_connector *conn = to_display_connector(bridge);
  89
  90         return drm_get_edid(connector, conn->bridge.ddc);
  91 }
  92
  93 /*
  94  * Since this bridge is tied to the connector, it acts like a passthrough,
  95  * so concerning the output bus formats, either pass the bus formats from the
  96  * previous bridge or return fallback data like done in the bridge function:
  97  * drm_atomic_bridge_chain_select_bus_fmts().
  98  * This supports negotiation if the bridge chain has all bits in place.
  99  */
 100 static u32 *display_connector_get_output_bus_fmts(struct drm_bridge *bridge,
 101                                         struct drm_bridge_state *bridge_state,
 102                                         struct drm_crtc_state *crtc_state,
 103                                         struct drm_connector_state *conn_state,
 104                                         unsigned int *num_output_fmts)
 105 {
 106         struct drm_bridge *prev_bridge = drm_bridge_get_prev_bridge(bridge);
 107         struct drm_bridge_state *prev_bridge_state;
 108
 109         if (!prev_bridge || !prev_bridge->funcs->atomic_get_output_bus_fmts) {
 110                 struct drm_connector *conn = conn_state->connector;
 111                 u32 *out_bus_fmts;
 112
 113                 *num_output_fmts = 1;
 114                 out_bus_fmts = kmalloc(sizeof(*out_bus_fmts), GFP_KERNEL);
 115                 if (!out_bus_fmts)
 116                         return NULL;
 117
 118                 if (conn->display_info.num_bus_formats &&
 119                     conn->display_info.bus_formats)
 120                         out_bus_fmts[0] = conn->display_info.bus_formats[0];
 121                 else
 122                         out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED;
 123
 124                 return out_bus_fmts;
 125         }
 126
 127         prev_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
 128                                                             prev_bridge);
 129
 130         return prev_bridge->funcs->atomic_get_output_bus_fmts(prev_bridge, prev_bridge_state,
 131                                                               crtc_state, conn_state,
 132                                                               num_output_fmts);
 133 }
 134
 135 /*
 136  * Since this bridge is tied to the connector, it acts like a passthrough,
 137  * so concerning the input bus formats, either pass the bus formats from the
 138  * previous bridge or MEDIA_BUS_FMT_FIXED (like select_bus_fmt_recursive())
 139  * when atomic_get_input_bus_fmts is not supported.
 140  * This supports negotiation if the bridge chain has all bits in place.
 141  */
 142 static u32 *display_connector_get_input_bus_fmts(struct drm_bridge *bridge,
 143                                         struct drm_bridge_state *bridge_state,
 144                                         struct drm_crtc_state *crtc_state,
 145                                         struct drm_connector_state *conn_state,
 146                                         u32 output_fmt,
 147                                         unsigned int *num_input_fmts)
 148 {
 149         struct drm_bridge *prev_bridge = drm_bridge_get_prev_bridge(bridge);
 150         struct drm_bridge_state *prev_bridge_state;
 151
 152         if (!prev_bridge || !prev_bridge->funcs->atomic_get_input_bus_fmts) {
 153                 u32 *in_bus_fmts;
 154
 155                 *num_input_fmts = 1;
 156                 in_bus_fmts = kmalloc(sizeof(*in_bus_fmts), GFP_KERNEL);
 157                 if (!in_bus_fmts)
 158                         return NULL;
 159
 160                 in_bus_fmts[0] = MEDIA_BUS_FMT_FIXED;
 161
 162                 return in_bus_fmts;
 163         }
 164
 165         prev_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
 166                                                             prev_bridge);
 167
 168         return prev_bridge->funcs->atomic_get_input_bus_fmts(prev_bridge, prev_bridge_state,
 169                                                              crtc_state, conn_state, output_fmt,
 170                                                              num_input_fmts);
 171 }
 172
 173 static const struct drm_bridge_funcs display_connector_bridge_funcs = {
 174         .attach = display_connector_attach,
 175         .detect = display_connector_detect,
 176         .get_edid = display_connector_get_edid,
 177         .atomic_get_output_bus_fmts = display_connector_get_output_bus_fmts,
 178         .atomic_get_input_bus_fmts = display_connector_get_input_bus_fmts,
 179         .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
 180         .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
 181         .atomic_reset = drm_atomic_helper_bridge_reset,
 182 };
 183
 184 static irqreturn_t display_connector_hpd_irq(int irq, void *arg)
 185 {
 186         struct display_connector *conn = arg;
 187         struct drm_bridge *bridge = &conn->bridge;
 188
 189         drm_bridge_hpd_notify(bridge, display_connector_detect(bridge));
 190
 191         return IRQ_HANDLED;
 192 }
 193
 194 static int display_connector_probe(struct platform_device *pdev)
 195 {
 196         struct display_connector *conn;
 197         unsigned int type;
 198         const char *label = NULL;
 199         int ret;
 200
 201         conn = devm_kzalloc(&pdev->dev, sizeof(*conn), GFP_KERNEL);
 202         if (!conn)
 203                 return -ENOMEM;
 204
 205         platform_set_drvdata(pdev, conn);
 206
 207         type = (uintptr_t)of_device_get_match_data(&pdev->dev);
 208
 209         /* Get the exact connector type. */
 210         switch (type) {
 211         case DRM_MODE_CONNECTOR_DVII: {
 212                 bool analog, digital;
 213
 214                 analog = of_property_read_bool(pdev->dev.of_node, "analog");
 215                 digital = of_property_read_bool(pdev->dev.of_node, "digital");
 216                 if (analog && !digital) {
 217                         conn->bridge.type = DRM_MODE_CONNECTOR_DVIA;
 218                 } else if (!analog && digital) {
 219                         conn->bridge.type = DRM_MODE_CONNECTOR_DVID;
 220                 } else if (analog && digital) {
 221                         conn->bridge.type = DRM_MODE_CONNECTOR_DVII;
 222                 } else {
 223                         dev_err(&pdev->dev, "DVI connector with no type\n");
 224                         return -EINVAL;
 225                 }
 226                 break;
 227         }
 228
 229         case DRM_MODE_CONNECTOR_HDMIA: {
 230                 const char *hdmi_type;
 231
 232                 ret = of_property_read_string(pdev->dev.of_node, "type",
 233                                               &hdmi_type);
 234                 if (ret < 0) {
 235                         dev_err(&pdev->dev, "HDMI connector with no type\n");
 236                         return -EINVAL;
 237                 }
 238
 239                 if (!strcmp(hdmi_type, "a") || !strcmp(hdmi_type, "c") ||
 240                     !strcmp(hdmi_type, "d") || !strcmp(hdmi_type, "e")) {
 241                         conn->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
 242                 } else if (!strcmp(hdmi_type, "b")) {
 243                         conn->bridge.type = DRM_MODE_CONNECTOR_HDMIB;
 244                 } else {
 245                         dev_err(&pdev->dev,
 246                                 "Unsupported HDMI connector type '%s'\n",
 247                                 hdmi_type);
 248                         return -EINVAL;
 249                 }
 250
 251                 break;
 252         }
 253
 254         default:
 255                 conn->bridge.type = type;
 256                 break;
 257         }
 258
 259         /* All the supported connector types support interlaced modes. */
 260         conn->bridge.interlace_allowed = true;
 261
 262         /* Get the optional connector label. */
 263         of_property_read_string(pdev->dev.of_node, "label", &label);
 264
 265         /*
 266          * Get the HPD GPIO for DVI, HDMI and DP connectors. If the GPIO can provide
 267          * edge interrupts, register an interrupt handler.
 268          */
 269         if (type == DRM_MODE_CONNECTOR_DVII ||
 270             type == DRM_MODE_CONNECTOR_HDMIA ||
 271             type == DRM_MODE_CONNECTOR_DisplayPort) {
 272                 conn->hpd_gpio = devm_gpiod_get_optional(&pdev->dev, "hpd",
 273                                                          GPIOD_IN);
 274                 if (IS_ERR(conn->hpd_gpio))
 275                         return dev_err_probe(&pdev->dev, PTR_ERR(conn->hpd_gpio),
 276                                              "Unable to retrieve HPD GPIO\n");
 277
 278                 conn->hpd_irq = gpiod_to_irq(conn->hpd_gpio);
 279         } else {
 280                 conn->hpd_irq = -EINVAL;
 281         }
 282
 283         if (conn->hpd_irq >= 0) {
 284                 ret = devm_request_threaded_irq(&pdev->dev, conn->hpd_irq,
 285                                                 NULL, display_connector_hpd_irq,
 286                                                 IRQF_TRIGGER_RISING |
 287                                                 IRQF_TRIGGER_FALLING |
 288                                                 IRQF_ONESHOT,
 289                                                 "HPD", conn);
 290                 if (ret) {
 291                         dev_info(&pdev->dev,
 292                                  "Failed to request HPD edge interrupt, falling back to polling\n");
 293                         conn->hpd_irq = -EINVAL;
 294                 }
 295         }
 296
 297         /* Retrieve the DDC I2C adapter for DVI, HDMI and VGA connectors. */
 298         if (type == DRM_MODE_CONNECTOR_DVII ||
 299             type == DRM_MODE_CONNECTOR_HDMIA ||
 300             type == DRM_MODE_CONNECTOR_VGA) {
 301                 struct device_node *phandle;
 302
 303                 phandle = of_parse_phandle(pdev->dev.of_node, "ddc-i2c-bus", 0);
 304                 if (phandle) {
 305                         conn->bridge.ddc = of_get_i2c_adapter_by_node(phandle);
 306                         of_node_put(phandle);
 307                         if (!conn->bridge.ddc)
 308                                 return -EPROBE_DEFER;
 309                 } else {
 310                         dev_dbg(&pdev->dev,
 311                                 "No I2C bus specified, disabling EDID readout\n");
 312                 }
 313         }
 314
 315         /* Get the DP PWR for DP connector. */
 316         if (type == DRM_MODE_CONNECTOR_DisplayPort) {
 317                 int ret;
 318
 319                 conn->dp_pwr = devm_regulator_get_optional(&pdev->dev, "dp-pwr");
 320
 321                 if (IS_ERR(conn->dp_pwr)) {
 322                         ret = PTR_ERR(conn->dp_pwr);
 323
 324                         switch (ret) {
 325                         case -ENODEV:
 326                                 conn->dp_pwr = NULL;
 327                                 break;
 328
 329                         case -EPROBE_DEFER:
 330                                 return -EPROBE_DEFER;
 331
 332                         default:
 333                                 dev_err(&pdev->dev, "failed to get DP PWR regulator: %d\n", ret);
 334                                 return ret;
 335                         }
 336                 }
 337
 338                 if (conn->dp_pwr) {
 339                         ret = regulator_enable(conn->dp_pwr);
 340                         if (ret) {
 341                                 dev_err(&pdev->dev, "failed to enable DP PWR regulator: %d\n", ret);
 342                                 return ret;
 343                         }
 344                 }
 345         }
 346
 347         /* enable DDC */
 348         if (type == DRM_MODE_CONNECTOR_HDMIA) {
 349                 conn->ddc_en = devm_gpiod_get_optional(&pdev->dev, "ddc-en",
 350                                                        GPIOD_OUT_HIGH);
 351
 352                 if (IS_ERR(conn->ddc_en)) {
 353                         dev_err(&pdev->dev, "Couldn't get ddc-en gpio\n");
 354                         return PTR_ERR(conn->ddc_en);
 355                 }
 356         }
 357
 358         conn->bridge.funcs = &display_connector_bridge_funcs;
 359         conn->bridge.of_node = pdev->dev.of_node;
 360
 361         if (conn->bridge.ddc)
 362                 conn->bridge.ops |= DRM_BRIDGE_OP_EDID
 363                                  |  DRM_BRIDGE_OP_DETECT;
 364         if (conn->hpd_gpio)
 365                 conn->bridge.ops |= DRM_BRIDGE_OP_DETECT;
 366         if (conn->hpd_irq >= 0)
 367                 conn->bridge.ops |= DRM_BRIDGE_OP_HPD;
 368
 369         dev_dbg(&pdev->dev,
 370                 "Found %s display connector '%s' %s DDC bus and %s HPD GPIO (ops 0x%x)\n",
 371                 drm_get_connector_type_name(conn->bridge.type),
 372                 label ? label : "<unlabelled>",
 373                 conn->bridge.ddc ? "with" : "without",
 374                 conn->hpd_gpio ? "with" : "without",
 375                 conn->bridge.ops);
 376
 377         drm_bridge_add(&conn->bridge);
 378
 379         return 0;
 380 }
 381
 382 static void display_connector_remove(struct platform_device *pdev)
 383 {
 384         struct display_connector *conn = platform_get_drvdata(pdev);
 385
 386         if (conn->ddc_en)
 387                 gpiod_set_value(conn->ddc_en, 0);
 388
 389         if (conn->dp_pwr)
 390                 regulator_disable(conn->dp_pwr);
 391
 392         drm_bridge_remove(&conn->bridge);
 393
 394         if (!IS_ERR(conn->bridge.ddc))
 395                 i2c_put_adapter(conn->bridge.ddc);
 396 }
 397
 398 static const struct of_device_id display_connector_match[] = {
 399         {
 400                 .compatible = "composite-video-connector",
 401                 .data = (void *)DRM_MODE_CONNECTOR_Composite,
 402         }, {
 403                 .compatible = "dvi-connector",
 404                 .data = (void *)DRM_MODE_CONNECTOR_DVII,
 405         }, {
 406                 .compatible = "hdmi-connector",
 407                 .data = (void *)DRM_MODE_CONNECTOR_HDMIA,
 408         }, {
 409                 .compatible = "svideo-connector",
 410                 .data = (void *)DRM_MODE_CONNECTOR_SVIDEO,
 411         }, {
 412                 .compatible = "vga-connector",
 413                 .data = (void *)DRM_MODE_CONNECTOR_VGA,
 414         }, {
 415                 .compatible = "dp-connector",
 416                 .data = (void *)DRM_MODE_CONNECTOR_DisplayPort,
 417         },
 418         {},
 419 };
 420 MODULE_DEVICE_TABLE(of, display_connector_match);
 421
 422 static struct platform_driver display_connector_driver = {
 423         .probe  = display_connector_probe,
 424         .remove_new = display_connector_remove,
 425         .driver         = {
 426                 .name           = "display-connector",
 427                 .of_match_table = display_connector_match,
 428         },
 429 };
 430 module_platform_driver(display_connector_driver);
 431
 432 MODULE_AUTHOR("Laurent Pinchart <[email protected]>");
 433 MODULE_DESCRIPTION("Display connector driver");
 434 MODULE_LICENSE("GPL");