drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2014 Traphandler
   4  * Copyright (C) 2014 Free Electrons
   5  * Copyright (C) 2014 Atmel
   6  *
   7  * Author: Jean-Jacques Hiblot <[email protected]>
   8  * Author: Boris BREZILLON <[email protected]>
   9  */
  10
  11 #include <linux/media-bus-format.h>
  12 #include <linux/of_graph.h>
  13
  14 #include <drm/drm_bridge.h>
  15 #include <drm/drm_encoder.h>
  16 #include <drm/drm_of.h>
  17 #include <drm/drm_simple_kms_helper.h>
  18
  19 #include "atmel_hlcdc_dc.h"
  20
  21 struct atmel_hlcdc_rgb_output {
  22         struct drm_encoder encoder;
  23         int bus_fmt;
  24 };
  25
  26 static struct atmel_hlcdc_rgb_output *
  27 atmel_hlcdc_encoder_to_rgb_output(struct drm_encoder *encoder)
  28 {
  29         return container_of(encoder, struct atmel_hlcdc_rgb_output, encoder);
  30 }
  31
  32 int atmel_hlcdc_encoder_get_bus_fmt(struct drm_encoder *encoder)
  33 {
  34         struct atmel_hlcdc_rgb_output *output;
  35
  36         output = atmel_hlcdc_encoder_to_rgb_output(encoder);
  37
  38         return output->bus_fmt;
  39 }
  40
  41 static int atmel_hlcdc_of_bus_fmt(const struct device_node *ep)
  42 {
  43         u32 bus_width;
  44         int ret;
  45
  46         ret = of_property_read_u32(ep, "bus-width", &bus_width);
  47         if (ret == -EINVAL)
  48                 return 0;
  49         if (ret)
  50                 return ret;
  51
  52         switch (bus_width) {
  53         case 12:
  54                 return MEDIA_BUS_FMT_RGB444_1X12;
  55         case 16:
  56                 return MEDIA_BUS_FMT_RGB565_1X16;
  57         case 18:
  58                 return MEDIA_BUS_FMT_RGB666_1X18;
  59         case 24:
  60                 return MEDIA_BUS_FMT_RGB888_1X24;
  61         default:
  62                 return -EINVAL;
  63         }
  64 }
  65
  66 static int atmel_hlcdc_attach_endpoint(struct drm_device *dev, int endpoint)
  67 {
  68         struct atmel_hlcdc_rgb_output *output;
  69         struct device_node *ep;
  70         struct drm_panel *panel;
  71         struct drm_bridge *bridge;
  72         int ret;
  73
  74         ep = of_graph_get_endpoint_by_regs(dev->dev->of_node, 0, endpoint);
  75         if (!ep)
  76                 return -ENODEV;
  77
  78         ret = drm_of_find_panel_or_bridge(dev->dev->of_node, 0, endpoint,
  79                                           &panel, &bridge);
  80         if (ret) {
  81                 of_node_put(ep);
  82                 return ret;
  83         }
  84
  85         output = devm_kzalloc(dev->dev, sizeof(*output), GFP_KERNEL);
  86         if (!output) {
  87                 of_node_put(ep);
  88                 return -ENOMEM;
  89         }
  90
  91         output->bus_fmt = atmel_hlcdc_of_bus_fmt(ep);
  92         of_node_put(ep);
  93         if (output->bus_fmt < 0) {
  94                 dev_err(dev->dev, "endpoint %d: invalid bus width\n", endpoint);
  95                 return -EINVAL;
  96         }
  97
  98         ret = drm_simple_encoder_init(dev, &output->encoder,
  99                                       DRM_MODE_ENCODER_NONE);
 100         if (ret)
 101                 return ret;
 102
 103         output->encoder.possible_crtcs = 0x1;
 104
 105         if (panel) {
 106                 bridge = drm_panel_bridge_add_typed(panel,
 107                                                     DRM_MODE_CONNECTOR_Unknown);
 108                 if (IS_ERR(bridge))
 109                         return PTR_ERR(bridge);
 110         }
 111
 112         if (bridge) {
 113                 ret = drm_bridge_attach(&output->encoder, bridge, NULL, 0);
 114                 if (!ret)
 115                         return 0;
 116
 117                 if (panel)
 118                         drm_panel_bridge_remove(bridge);
 119         }
 120
 121         drm_encoder_cleanup(&output->encoder);
 122
 123         return ret;
 124 }
 125
 126 int atmel_hlcdc_create_outputs(struct drm_device *dev)
 127 {
 128         int endpoint, ret = 0;
 129         int attached = 0;
 130
 131         /*
 132          * Always scan the first few endpoints even if we get -ENODEV,
 133          * but keep going after that as long as we keep getting hits.
 134          */
 135         for (endpoint = 0; !ret || endpoint < 4; endpoint++) {
 136                 ret = atmel_hlcdc_attach_endpoint(dev, endpoint);
 137                 if (ret == -ENODEV)
 138                         continue;
 139                 if (ret)
 140                         break;
 141                 attached++;
 142         }
 143
 144         /* At least one device was successfully attached.*/
 145         if (ret == -ENODEV && attached)
 146                 return 0;
 147
 148         return ret;
 149 }