drm/bridge/simple-bridge.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2015-2016 Free Electrons
0004  * Copyright (C) 2015-2016 NextThing Co
0005  *
0006  * Maxime Ripard <maxime.ripard@free-electrons.com>
0007  */
0008
0009 #include <linux/gpio/consumer.h>
0010 #include <linux/module.h>
0011 #include <linux/of_device.h>
0012 #include <linux/of_graph.h>
0013 #include <linux/regulator/consumer.h>
0014
0015 #include <drm/drm_atomic_helper.h>
0016 #include <drm/drm_bridge.h>
0017 #include <drm/drm_crtc.h>
0018 #include <drm/drm_edid.h>
0019 #include <drm/drm_print.h>
0020 #include <drm/drm_probe_helper.h>
0021
0022 struct simple_bridge_info {
0023     const struct drm_bridge_timings *timings;
0024     unsigned int connector_type;
0025 };
0026
0027 struct simple_bridge {
0028     struct drm_bridge   bridge;
0029     struct drm_connector    connector;
0030
0031     const struct simple_bridge_info *info;
0032
0033     struct drm_bridge   *next_bridge;
0034     struct regulator    *vdd;
0035     struct gpio_desc    *enable;
0036 };
0037
0038 static inline struct simple_bridge *
0039 drm_bridge_to_simple_bridge(struct drm_bridge *bridge)
0040 {
0041     return container_of(bridge, struct simple_bridge, bridge);
0042 }
0043
0044 static inline struct simple_bridge *
0045 drm_connector_to_simple_bridge(struct drm_connector *connector)
0046 {
0047     return container_of(connector, struct simple_bridge, connector);
0048 }
0049
0050 static int simple_bridge_get_modes(struct drm_connector *connector)
0051 {
0052     struct simple_bridge *sbridge = drm_connector_to_simple_bridge(connector);
0053     struct edid *edid;
0054     int ret;
0055
0056     if (sbridge->next_bridge->ops & DRM_BRIDGE_OP_EDID) {
0057         edid = drm_bridge_get_edid(sbridge->next_bridge, connector);
0058         if (!edid)
0059             DRM_INFO("EDID read failed. Fallback to standard modes\n");
0060     } else {
0061         edid = NULL;
0062     }
0063
0064     if (!edid) {
0065         /*
0066          * In case we cannot retrieve the EDIDs (missing or broken DDC
0067          * bus from the next bridge), fallback on the XGA standards and
0068          * prefer a mode pretty much anyone can handle.
0069          */
0070         ret = drm_add_modes_noedid(connector, 1920, 1200);
0071         drm_set_preferred_mode(connector, 1024, 768);
0072         return ret;
0073     }
0074
0075     drm_connector_update_edid_property(connector, edid);
0076     ret = drm_add_edid_modes(connector, edid);
0077     kfree(edid);
0078
0079     return ret;
0080 }
0081
0082 static const struct drm_connector_helper_funcs simple_bridge_con_helper_funcs = {
0083     .get_modes  = simple_bridge_get_modes,
0084 };
0085
0086 static enum drm_connector_status
0087 simple_bridge_connector_detect(struct drm_connector *connector, bool force)
0088 {
0089     struct simple_bridge *sbridge = drm_connector_to_simple_bridge(connector);
0090
0091     return drm_bridge_detect(sbridge->next_bridge);
0092 }
0093
0094 static const struct drm_connector_funcs simple_bridge_con_funcs = {
0095     .detect         = simple_bridge_connector_detect,
0096     .fill_modes     = drm_helper_probe_single_connector_modes,
0097     .destroy        = drm_connector_cleanup,
0098     .reset          = drm_atomic_helper_connector_reset,
0099     .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
0100     .atomic_destroy_state   = drm_atomic_helper_connector_destroy_state,
0101 };
0102
0103 static int simple_bridge_attach(struct drm_bridge *bridge,
0104                 enum drm_bridge_attach_flags flags)
0105 {
0106     struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
0107     int ret;
0108
0109     ret = drm_bridge_attach(bridge->encoder, sbridge->next_bridge, bridge,
0110                 DRM_BRIDGE_ATTACH_NO_CONNECTOR);
0111     if (ret < 0)
0112         return ret;
0113
0114     if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
0115         return 0;
0116
0117     if (!bridge->encoder) {
0118         DRM_ERROR("Missing encoder\n");
0119         return -ENODEV;
0120     }
0121
0122     drm_connector_helper_add(&sbridge->connector,
0123                  &simple_bridge_con_helper_funcs);
0124     ret = drm_connector_init_with_ddc(bridge->dev, &sbridge->connector,
0125                       &simple_bridge_con_funcs,
0126                       sbridge->info->connector_type,
0127                       sbridge->next_bridge->ddc);
0128     if (ret) {
0129         DRM_ERROR("Failed to initialize connector\n");
0130         return ret;
0131     }
0132
0133     drm_connector_attach_encoder(&sbridge->connector, bridge->encoder);
0134
0135     return 0;
0136 }
0137
0138 static void simple_bridge_enable(struct drm_bridge *bridge)
0139 {
0140     struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
0141     int ret;
0142
0143     if (sbridge->vdd) {
0144         ret = regulator_enable(sbridge->vdd);
0145         if (ret)
0146             DRM_ERROR("Failed to enable vdd regulator: %d\n", ret);
0147     }
0148
0149     gpiod_set_value_cansleep(sbridge->enable, 1);
0150 }
0151
0152 static void simple_bridge_disable(struct drm_bridge *bridge)
0153 {
0154     struct simple_bridge *sbridge = drm_bridge_to_simple_bridge(bridge);
0155
0156     gpiod_set_value_cansleep(sbridge->enable, 0);
0157
0158     if (sbridge->vdd)
0159         regulator_disable(sbridge->vdd);
0160 }
0161
0162 static const struct drm_bridge_funcs simple_bridge_bridge_funcs = {
0163     .attach     = simple_bridge_attach,
0164     .enable     = simple_bridge_enable,
0165     .disable    = simple_bridge_disable,
0166 };
0167
0168 static int simple_bridge_probe(struct platform_device *pdev)
0169 {
0170     struct simple_bridge *sbridge;
0171     struct device_node *remote;
0172
0173     sbridge = devm_kzalloc(&pdev->dev, sizeof(*sbridge), GFP_KERNEL);
0174     if (!sbridge)
0175         return -ENOMEM;
0176     platform_set_drvdata(pdev, sbridge);
0177
0178     sbridge->info = of_device_get_match_data(&pdev->dev);
0179
0180     /* Get the next bridge in the pipeline. */
0181     remote = of_graph_get_remote_node(pdev->dev.of_node, 1, -1);
0182     if (!remote)
0183         return -EINVAL;
0184
0185     sbridge->next_bridge = of_drm_find_bridge(remote);
0186     of_node_put(remote);
0187
0188     if (!sbridge->next_bridge) {
0189         dev_dbg(&pdev->dev, "Next bridge not found, deferring probe\n");
0190         return -EPROBE_DEFER;
0191     }
0192
0193     /* Get the regulator and GPIO resources. */
0194     sbridge->vdd = devm_regulator_get_optional(&pdev->dev, "vdd");
0195     if (IS_ERR(sbridge->vdd)) {
0196         int ret = PTR_ERR(sbridge->vdd);
0197         if (ret == -EPROBE_DEFER)
0198             return -EPROBE_DEFER;
0199         sbridge->vdd = NULL;
0200         dev_dbg(&pdev->dev, "No vdd regulator found: %d\n", ret);
0201     }
0202
0203     sbridge->enable = devm_gpiod_get_optional(&pdev->dev, "enable",
0204                           GPIOD_OUT_LOW);
0205     if (IS_ERR(sbridge->enable)) {
0206         if (PTR_ERR(sbridge->enable) != -EPROBE_DEFER)
0207             dev_err(&pdev->dev, "Unable to retrieve enable GPIO\n");
0208         return PTR_ERR(sbridge->enable);
0209     }
0210
0211     /* Register the bridge. */
0212     sbridge->bridge.funcs = &simple_bridge_bridge_funcs;
0213     sbridge->bridge.of_node = pdev->dev.of_node;
0214     sbridge->bridge.timings = sbridge->info->timings;
0215
0216     drm_bridge_add(&sbridge->bridge);
0217
0218     return 0;
0219 }
0220
0221 static int simple_bridge_remove(struct platform_device *pdev)
0222 {
0223     struct simple_bridge *sbridge = platform_get_drvdata(pdev);
0224
0225     drm_bridge_remove(&sbridge->bridge);
0226
0227     return 0;
0228 }
0229
0230 /*
0231  * We assume the ADV7123 DAC is the "default" for historical reasons
0232  * Information taken from the ADV7123 datasheet, revision D.
0233  * NOTE: the ADV7123EP seems to have other timings and need a new timings
0234  * set if used.
0235  */
0236 static const struct drm_bridge_timings default_bridge_timings = {
0237     /* Timing specifications, datasheet page 7 */
0238     .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
0239     .setup_time_ps = 500,
0240     .hold_time_ps = 1500,
0241 };
0242
0243 /*
0244  * Information taken from the THS8134, THS8134A, THS8134B datasheet named
0245  * "SLVS205D", dated May 1990, revised March 2000.
0246  */
0247 static const struct drm_bridge_timings ti_ths8134_bridge_timings = {
0248     /* From timing diagram, datasheet page 9 */
0249     .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
0250     /* From datasheet, page 12 */
0251     .setup_time_ps = 3000,
0252     /* I guess this means latched input */
0253     .hold_time_ps = 0,
0254 };
0255
0256 /*
0257  * Information taken from the THS8135 datasheet named "SLAS343B", dated
0258  * May 2001, revised April 2013.
0259  */
0260 static const struct drm_bridge_timings ti_ths8135_bridge_timings = {
0261     /* From timing diagram, datasheet page 14 */
0262     .input_bus_flags = DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE,
0263     /* From datasheet, page 16 */
0264     .setup_time_ps = 2000,
0265     .hold_time_ps = 500,
0266 };
0267
0268 static const struct of_device_id simple_bridge_match[] = {
0269     {
0270         .compatible = "dumb-vga-dac",
0271         .data = &(const struct simple_bridge_info) {
0272             .connector_type = DRM_MODE_CONNECTOR_VGA,
0273         },
0274     }, {
0275         .compatible = "adi,adv7123",
0276         .data = &(const struct simple_bridge_info) {
0277             .timings = &default_bridge_timings,
0278             .connector_type = DRM_MODE_CONNECTOR_VGA,
0279         },
0280     }, {
0281         .compatible = "ti,opa362",
0282         .data = &(const struct simple_bridge_info) {
0283             .connector_type = DRM_MODE_CONNECTOR_Composite,
0284         },
0285     }, {
0286         .compatible = "ti,ths8135",
0287         .data = &(const struct simple_bridge_info) {
0288             .timings = &ti_ths8135_bridge_timings,
0289             .connector_type = DRM_MODE_CONNECTOR_VGA,
0290         },
0291     }, {
0292         .compatible = "ti,ths8134",
0293         .data = &(const struct simple_bridge_info) {
0294             .timings = &ti_ths8134_bridge_timings,
0295             .connector_type = DRM_MODE_CONNECTOR_VGA,
0296         },
0297     },
0298     {},
0299 };
0300 MODULE_DEVICE_TABLE(of, simple_bridge_match);
0301
0302 static struct platform_driver simple_bridge_driver = {
0303     .probe  = simple_bridge_probe,
0304     .remove = simple_bridge_remove,
0305     .driver     = {
0306         .name       = "simple-bridge",
0307         .of_match_table = simple_bridge_match,
0308     },
0309 };
0310 module_platform_driver(simple_bridge_driver);
0311
0312 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
0313 MODULE_DESCRIPTION("Simple DRM bridge driver");
0314 MODULE_LICENSE("GPL");