drivers/gpu/drm/bridge/lvds-encoder.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2016 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
   4  */
   5
   6 #include <drm/drmP.h>
   7 #include <drm/drm_bridge.h>
   8 #include <drm/drm_panel.h>
   9
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/of_graph.h>
  12
  13 struct lvds_encoder {
  14         struct drm_bridge bridge;
  15         struct drm_bridge *panel_bridge;
  16         struct gpio_desc *powerdown_gpio;
  17 };
  18
  19 static int lvds_encoder_attach(struct drm_bridge *bridge)
  20 {
  21         struct lvds_encoder *lvds_encoder = container_of(bridge,
  22                                                          struct lvds_encoder,
  23                                                          bridge);
  24
  25         return drm_bridge_attach(bridge->encoder, lvds_encoder->panel_bridge,
  26                                  bridge);
  27 }
  28
  29 static void lvds_encoder_enable(struct drm_bridge *bridge)
  30 {
  31         struct lvds_encoder *lvds_encoder = container_of(bridge,
  32                                                          struct lvds_encoder,
  33                                                          bridge);
  34
  35         if (lvds_encoder->powerdown_gpio)
  36                 gpiod_set_value_cansleep(lvds_encoder->powerdown_gpio, 0);
  37 }
  38
  39 static void lvds_encoder_disable(struct drm_bridge *bridge)
  40 {
  41         struct lvds_encoder *lvds_encoder = container_of(bridge,
  42                                                          struct lvds_encoder,
  43                                                          bridge);
  44
  45         if (lvds_encoder->powerdown_gpio)
  46                 gpiod_set_value_cansleep(lvds_encoder->powerdown_gpio, 1);
  47 }
  48
  49 static struct drm_bridge_funcs funcs = {
  50         .attach = lvds_encoder_attach,
  51         .enable = lvds_encoder_enable,
  52         .disable = lvds_encoder_disable,
  53 };
  54
  55 static int lvds_encoder_probe(struct platform_device *pdev)
  56 {
  57         struct device *dev = &pdev->dev;
  58         struct device_node *port;
  59         struct device_node *endpoint;
  60         struct device_node *panel_node;
  61         struct drm_panel *panel;
  62         struct lvds_encoder *lvds_encoder;
  63
  64         lvds_encoder = devm_kzalloc(dev, sizeof(*lvds_encoder), GFP_KERNEL);
  65         if (!lvds_encoder)
  66                 return -ENOMEM;
  67
  68         lvds_encoder->powerdown_gpio = devm_gpiod_get_optional(dev, "powerdown",
  69                                                                GPIOD_OUT_HIGH);
  70         if (IS_ERR(lvds_encoder->powerdown_gpio)) {
  71                 int err = PTR_ERR(lvds_encoder->powerdown_gpio);
  72
  73                 if (err != -EPROBE_DEFER)
  74                         dev_err(dev, "powerdown GPIO failure: %d\n", err);
  75                 return err;
  76         }
  77
  78         /* Locate the panel DT node. */
  79         port = of_graph_get_port_by_id(dev->of_node, 1);
  80         if (!port) {
  81                 dev_dbg(dev, "port 1 not found\n");
  82                 return -ENXIO;
  83         }
  84
  85         endpoint = of_get_child_by_name(port, "endpoint");
  86         of_node_put(port);
  87         if (!endpoint) {
  88                 dev_dbg(dev, "no endpoint for port 1\n");
  89                 return -ENXIO;
  90         }
  91
  92         panel_node = of_graph_get_remote_port_parent(endpoint);
  93         of_node_put(endpoint);
  94         if (!panel_node) {
  95                 dev_dbg(dev, "no remote endpoint for port 1\n");
  96                 return -ENXIO;
  97         }
  98
  99         panel = of_drm_find_panel(panel_node);
 100         of_node_put(panel_node);
 101         if (IS_ERR(panel)) {
 102                 dev_dbg(dev, "panel not found, deferring probe\n");
 103                 return PTR_ERR(panel);
 104         }
 105
 106         lvds_encoder->panel_bridge =
 107                 devm_drm_panel_bridge_add(dev, panel, DRM_MODE_CONNECTOR_LVDS);
 108         if (IS_ERR(lvds_encoder->panel_bridge))
 109                 return PTR_ERR(lvds_encoder->panel_bridge);
 110
 111         /* The panel_bridge bridge is attached to the panel's of_node,
 112          * but we need a bridge attached to our of_node for our user
 113          * to look up.
 114          */
 115         lvds_encoder->bridge.of_node = dev->of_node;
 116         lvds_encoder->bridge.funcs = &funcs;
 117         drm_bridge_add(&lvds_encoder->bridge);
 118
 119         platform_set_drvdata(pdev, lvds_encoder);
 120
 121         return 0;
 122 }
 123
 124 static int lvds_encoder_remove(struct platform_device *pdev)
 125 {
 126         struct lvds_encoder *lvds_encoder = platform_get_drvdata(pdev);
 127
 128         drm_bridge_remove(&lvds_encoder->bridge);
 129
 130         return 0;
 131 }
 132
 133 static const struct of_device_id lvds_encoder_match[] = {
 134         { .compatible = "lvds-encoder" },
 135         { .compatible = "thine,thc63lvdm83d" },
 136         {},
 137 };
 138 MODULE_DEVICE_TABLE(of, lvds_encoder_match);
 139
 140 static struct platform_driver lvds_encoder_driver = {
 141         .probe  = lvds_encoder_probe,
 142         .remove = lvds_encoder_remove,
 143         .driver         = {
 144                 .name           = "lvds-encoder",
 145                 .of_match_table = lvds_encoder_match,
 146         },
 147 };
 148 module_platform_driver(lvds_encoder_driver);
 149
 150 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
 151 MODULE_DESCRIPTION("Transparent parallel to LVDS encoder");
 152 MODULE_LICENSE("GPL");