drivers/gpu/drm/bridge/simple-bridge.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2015-2016 Free Electrons
   4  * Copyright (C) 2015-2016 NextThing Co
   5  *
   6  * Maxime Ripard <[email protected]>
   7  */
   8
   9 #include <linux/gpio/consumer.h>
  10 #include <linux/module.h>
  11 #include <linux/of.h>
  12 #include <linux/of_graph.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_crtc.h>
  19 #include <drm/drm_edid.h>
  20 #include <drm/drm_print.h>
  21 #include <drm/drm_probe_helper.h>
  22
  23 struct simple_bridge_info {
  24         const struct drm_bridge_timings *timings;
  25         unsigned int connector_type;
  26 };
  27
  28 struct simple_bridge {
  29         struct drm_bridge       bridge;
  30         struct drm_connector    connector;
  31
  32         const struct simple_bridge_info *info;
  33
  34         struct drm_bridge       *next_bridge;
  35         struct regulator        *vdd;
  36         struct gpio_desc        *enable;
  37 };
  38
  39 static inline struct simple_bridge *
  40 drm_bridge_to_simple_bridge(struct drm_bridge *bridge)
  41 {
  42         return container_of(bridge, struct simple_bridge, bridge);
  43 }
  44
  45 static inline struct simple_bridge *
  46 drm_connector_to_simple_bridge(struct drm_connector *connector)
  47 {
  48         return container_of(connector, struct simple_bridge, connector);
  49 }
  50
  51 static int simple_bridge_get_modes(struct drm_connector *connector)
  52 {
  53         struct simple_bridge *sbridge = drm_connector_to_simple_bridge(connector);
  54         const struct drm_edid *drm_edid;
  55         int ret;
  56
  57         if (sbridge->next_bridge->ops & DRM_BRIDGE_OP_EDID) {
  58                 drm_edid = drm_bridge_edid_read(sbridge->next_bridge, connector);
  59                 if (!drm_edid)
  60                         DRM_INFO("EDID read failed. Fallback to standard modes\n");
  61         } else {
  62                 drm_edid = NULL;
  63         }
  64
  65         drm_edid_connector_update(connector, drm_edid);
  66
  67         if (!drm_edid) {
  68                 /*
  69                  * In case we cannot retrieve the EDIDs (missing or broken DDC
  70                  * bus from the next bridge), fallback on the XGA standards and
  71                  * prefer a mode pretty much anyone can handle.
  72                  */
  73                 ret = drm_add_modes_noedid(connector, 1920, 1200);
  74                 drm_set_preferred_mode(connector, 1024, 768);
  75                 return ret;
  76         }
  77
  78         ret = drm_edid_connector_add_modes(connector);
  79         drm_edid_free(drm_edid);
  80
  81         return ret;
  82 }
  83
  84 static const struct drm_connector_helper_funcs simple_bridge_con_helper_funcs = {
  85         .get_modes      = simple_bridge_get_modes,
  86 };
  87
  88 static enum drm_connector_status
  89 simple_bridge_connector_detect(struct drm_connector *connector, bool force)
  90 {
  91         struct simple_bridge *sbridge = drm_connector_to_simple_bridge(connector);
  92
  93         return drm_bridge_detect(sbridge->next_bridge);
  94 }
  95
  96 static const struct drm_connector_funcs simple_bridge_con_funcs = {
  97         .detect                 = simple_bridge_connector_detect,
  98         .fill_modes             = drm_helper_probe_single_connector_modes,
  99         .destroy                = drm_connector_cleanup,
 100         .reset                  = drm_atomic_helper_connector_reset,
 101         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 102         .atomic_destroy_state   = drm_atomic_helper_connector_destroy_state,
 103 };
 104
 105 static int simple_bridge_attach(struct drm_bridge *bridge,
 106                                 enum drm_bridge_attach_flags flags)
 107 {
 108         struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
 109         int ret;
 110
 111         ret = drm_bridge_attach(bridge->encoder, sbridge->next_bridge, bridge,
 112                                 DRM_BRIDGE_ATTACH_NO_CONNECTOR);
 113         if (ret < 0)
 114                 return ret;
 115
 116         if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
 117                 return 0;
 118
 119         drm_connector_helper_add(&sbridge->connector,
 120                                  &simple_bridge_con_helper_funcs);
 121         ret = drm_connector_init_with_ddc(bridge->dev, &sbridge->connector,
 122                                           &simple_bridge_con_funcs,
 123                                           sbridge->info->connector_type,
 124                                           sbridge->next_bridge->ddc);
 125         if (ret) {
 126                 DRM_ERROR("Failed to initialize connector\n");
 127                 return ret;
 128         }
 129
 130         drm_connector_attach_encoder(&sbridge->connector, bridge->encoder);
 131
 132         return 0;
 133 }
 134
 135 static void simple_bridge_enable(struct drm_bridge *bridge)
 136 {
 137         struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
 138         int ret;
 139
 140         if (sbridge->vdd) {
 141                 ret = regulator_enable(sbridge->vdd);
 142                 if (ret)
 143                         DRM_ERROR("Failed to enable vdd regulator: %d\n", ret);
 144         }
 145
 146         gpiod_set_value_cansleep(sbridge->enable, 1);
 147 }
 148
 149 static void simple_bridge_disable(struct drm_bridge *bridge)
 150 {
 151         struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
 152
 153         gpiod_set_value_cansleep(sbridge->enable, 0);
 154
 155         if (sbridge->vdd)
 156                 regulator_disable(sbridge->vdd);
 157 }
 158
 159 static const struct drm_bridge_funcs simple_bridge_bridge_funcs = {
 160         .attach         = simple_bridge_attach,
 161         .enable         = simple_bridge_enable,
 162         .disable        = simple_bridge_disable,
 163 };
 164
 165 static int simple_bridge_probe(struct platform_device *pdev)
 166 {
 167         struct simple_bridge *sbridge;
 168         struct device_node *remote;
 169
 170         sbridge = devm_kzalloc(&pdev->dev, sizeof(*sbridge), GFP_KERNEL);
 171         if (!sbridge)
 172                 return -ENOMEM;
 173
 174         sbridge->info = of_device_get_match_data(&pdev->dev);
 175
 176         /* Get the next bridge in the pipeline. */
 177         remote = of_graph_get_remote_node(pdev->dev.of_node, 1, -1);
 178         if (!remote)
 179                 return -EINVAL;
 180
 181         sbridge->next_bridge = of_drm_find_bridge(remote);
 182         of_node_put(remote);
 183
 184         if (!sbridge->next_bridge) {
 185                 dev_dbg(&pdev->dev, "Next bridge not found, deferring probe\n");
 186                 return -EPROBE_DEFER;
 187         }
 188
 189         /* Get the regulator and GPIO resources. */
 190         sbridge->vdd = devm_regulator_get_optional(&pdev->dev, "vdd");
 191         if (IS_ERR(sbridge->vdd)) {
 192                 int ret = PTR_ERR(sbridge->vdd);
 193                 if (ret == -EPROBE_DEFER)
 194                         return -EPROBE_DEFER;
 195                 sbridge->vdd = NULL;
 196                 dev_dbg(&pdev->dev, "No vdd regulator found: %d\n", ret);
 197         }
 198
 199         sbridge->enable = devm_gpiod_get_optional(&pdev->dev, "enable",
 200                                                   GPIOD_OUT_LOW);
 201         if (IS_ERR(sbridge->enable))
 202                 return dev_err_probe(&pdev->dev, PTR_ERR(sbridge->enable),
 203                                      "Unable to retrieve enable GPIO\n");
 204
 205         /* Register the bridge. */
 206         sbridge->bridge.funcs = &simple_bridge_bridge_funcs;
 207         sbridge->bridge.of_node = pdev->dev.of_node;
 208         sbridge->bridge.timings = sbridge->info->timings;
 209
 210         return devm_drm_bridge_add(&pdev->dev, &sbridge->bridge);
 211 }
 212
 213 /*
 214  * We assume the ADV7123 DAC is the "default" for historical reasons
 215  * Information taken from the ADV7123 datasheet, revision D.
 216  * NOTE: the ADV7123EP seems to have other timings and need a new timings
 217  * set if used.
 218  */
 219 static const struct drm_bridge_timings default_bridge_timings = {
 220         /* Timing specifications, datasheet page 7 */
 221         .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
 222         .setup_time_ps = 500,
 223         .hold_time_ps = 1500,
 224 };
 225
 226 /*
 227  * Information taken from the THS8134, THS8134A, THS8134B datasheet named
 228  * "SLVS205D", dated May 1990, revised March 2000.
 229  */
 230 static const struct drm_bridge_timings ti_ths8134_bridge_timings = {
 231         /* From timing diagram, datasheet page 9 */
 232         .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
 233         /* From datasheet, page 12 */
 234         .setup_time_ps = 3000,
 235         /* I guess this means latched input */
 236         .hold_time_ps = 0,
 237 };
 238
 239 /*
 240  * Information taken from the THS8135 datasheet named "SLAS343B", dated
 241  * May 2001, revised April 2013.
 242  */
 243 static const struct drm_bridge_timings ti_ths8135_bridge_timings = {
 244         /* From timing diagram, datasheet page 14 */
 245         .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
 246         /* From datasheet, page 16 */
 247         .setup_time_ps = 2000,
 248         .hold_time_ps = 500,
 249 };
 250
 251 static const struct of_device_id simple_bridge_match[] = {
 252         {
 253                 .compatible = "dumb-vga-dac",
 254                 .data = &(const struct simple_bridge_info) {
 255                         .connector_type = DRM_MODE_CONNECTOR_VGA,
 256                 },
 257         }, {
 258                 .compatible = "adi,adv7123",
 259                 .data = &(const struct simple_bridge_info) {
 260                         .timings = &default_bridge_timings,
 261                         .connector_type = DRM_MODE_CONNECTOR_VGA,
 262                 },
 263         }, {
 264                 .compatible = "ti,opa362",
 265                 .data = &(const struct simple_bridge_info) {
 266                         .connector_type = DRM_MODE_CONNECTOR_Composite,
 267                 },
 268         }, {
 269                 .compatible = "ti,ths8135",
 270                 .data = &(const struct simple_bridge_info) {
 271                         .timings = &ti_ths8135_bridge_timings,
 272                         .connector_type = DRM_MODE_CONNECTOR_VGA,
 273                 },
 274         }, {
 275                 .compatible = "ti,ths8134",
 276                 .data = &(const struct simple_bridge_info) {
 277                         .timings = &ti_ths8134_bridge_timings,
 278                         .connector_type = DRM_MODE_CONNECTOR_VGA,
 279                 },
 280         },
 281         {},
 282 };
 283 MODULE_DEVICE_TABLE(of, simple_bridge_match);
 284
 285 static struct platform_driver simple_bridge_driver = {
 286         .probe  = simple_bridge_probe,
 287         .driver         = {
 288                 .name           = "simple-bridge",
 289                 .of_match_table = simple_bridge_match,
 290         },
 291 };
 292 module_platform_driver(simple_bridge_driver);
 293
 294 MODULE_AUTHOR("Maxime Ripard <[email protected]>");
 295 MODULE_DESCRIPTION("Simple DRM bridge driver");
 296 MODULE_LICENSE("GPL");