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

   1 /*
   2  * Copyright (C) 2014 Traphandler
   3  * Copyright (C) 2014 Free Electrons
   4  * Copyright (C) 2014 Atmel
   5  *
   6  * Author: Jean-Jacques Hiblot <jjhiblot@traphandler.com>
   7  * Author: Boris BREZILLON <boris.brezillon@free-electrons.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License version 2 as published by
  11  * the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along with
  19  * this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <linux/of_graph.h>
  23
  24 #include <drm/drmP.h>
  25 #include <drm/drm_panel.h>
  26
  27 #include "atmel_hlcdc_dc.h"
  28
  29 /**
  30  * Atmel HLCDC RGB connector structure
  31  *
  32  * This structure stores RGB slave device information.
  33  *
  34  * @connector: DRM connector
  35  * @encoder: DRM encoder
  36  * @dc: pointer to the atmel_hlcdc_dc structure
  37  * @panel: panel connected on the RGB output
  38  */
  39 struct atmel_hlcdc_rgb_output {
  40         struct drm_connector connector;
  41         struct drm_encoder encoder;
  42         struct atmel_hlcdc_dc *dc;
  43         struct drm_panel *panel;
  44 };
  45
  46 static inline struct atmel_hlcdc_rgb_output *
  47 drm_connector_to_atmel_hlcdc_rgb_output(struct drm_connector *connector)
  48 {
  49         return container_of(connector, struct atmel_hlcdc_rgb_output,
  50                             connector);
  51 }
  52
  53 static inline struct atmel_hlcdc_rgb_output *
  54 drm_encoder_to_atmel_hlcdc_rgb_output(struct drm_encoder *encoder)
  55 {
  56         return container_of(encoder, struct atmel_hlcdc_rgb_output, encoder);
  57 }
  58
  59 static void atmel_hlcdc_rgb_encoder_enable(struct drm_encoder *encoder)
  60 {
  61         struct atmel_hlcdc_rgb_output *rgb =
  62                         drm_encoder_to_atmel_hlcdc_rgb_output(encoder);
  63
  64         if (rgb->panel) {
  65                 drm_panel_prepare(rgb->panel);
  66                 drm_panel_enable(rgb->panel);
  67         }
  68 }
  69
  70 static void atmel_hlcdc_rgb_encoder_disable(struct drm_encoder *encoder)
  71 {
  72         struct atmel_hlcdc_rgb_output *rgb =
  73                         drm_encoder_to_atmel_hlcdc_rgb_output(encoder);
  74
  75         if (rgb->panel) {
  76                 drm_panel_disable(rgb->panel);
  77                 drm_panel_unprepare(rgb->panel);
  78         }
  79 }
  80
  81 static const struct drm_encoder_helper_funcs atmel_hlcdc_panel_encoder_helper_funcs = {
  82         .disable = atmel_hlcdc_rgb_encoder_disable,
  83         .enable = atmel_hlcdc_rgb_encoder_enable,
  84 };
  85
  86 static void atmel_hlcdc_rgb_encoder_destroy(struct drm_encoder *encoder)
  87 {
  88         drm_encoder_cleanup(encoder);
  89         memset(encoder, 0, sizeof(*encoder));
  90 }
  91
  92 static const struct drm_encoder_funcs atmel_hlcdc_panel_encoder_funcs = {
  93         .destroy = atmel_hlcdc_rgb_encoder_destroy,
  94 };
  95
  96 static int atmel_hlcdc_panel_get_modes(struct drm_connector *connector)
  97 {
  98         struct atmel_hlcdc_rgb_output *rgb =
  99                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 100
 101         if (rgb->panel)
 102                 return rgb->panel->funcs->get_modes(rgb->panel);
 103
 104         return 0;
 105 }
 106
 107 static int atmel_hlcdc_rgb_mode_valid(struct drm_connector *connector,
 108                                       struct drm_display_mode *mode)
 109 {
 110         struct atmel_hlcdc_rgb_output *rgb =
 111                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 112
 113         return atmel_hlcdc_dc_mode_valid(rgb->dc, mode);
 114 }
 115
 116
 117
 118 static struct drm_encoder *
 119 atmel_hlcdc_rgb_best_encoder(struct drm_connector *connector)
 120 {
 121         struct atmel_hlcdc_rgb_output *rgb =
 122                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 123
 124         return &rgb->encoder;
 125 }
 126
 127 static const struct drm_connector_helper_funcs atmel_hlcdc_panel_connector_helper_funcs = {
 128         .get_modes = atmel_hlcdc_panel_get_modes,
 129         .mode_valid = atmel_hlcdc_rgb_mode_valid,
 130         .best_encoder = atmel_hlcdc_rgb_best_encoder,
 131 };
 132
 133 static enum drm_connector_status
 134 atmel_hlcdc_panel_connector_detect(struct drm_connector *connector, bool force)
 135 {
 136         struct atmel_hlcdc_rgb_output *rgb =
 137                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 138
 139         if (rgb->panel)
 140                 return connector_status_connected;
 141
 142         return connector_status_disconnected;
 143 }
 144
 145 static void
 146 atmel_hlcdc_panel_connector_destroy(struct drm_connector *connector)
 147 {
 148         struct atmel_hlcdc_rgb_output *rgb =
 149                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 150
 151         if (rgb->panel)
 152                 drm_panel_detach(rgb->panel);
 153
 154         drm_connector_cleanup(connector);
 155 }
 156
 157 static const struct drm_connector_funcs atmel_hlcdc_panel_connector_funcs = {
 158         .dpms = drm_atomic_helper_connector_dpms,
 159         .detect = atmel_hlcdc_panel_connector_detect,
 160         .fill_modes = drm_helper_probe_single_connector_modes,
 161         .destroy = atmel_hlcdc_panel_connector_destroy,
 162         .reset = drm_atomic_helper_connector_reset,
 163         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 164         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 165 };
 166
 167 static int atmel_hlcdc_check_endpoint(struct drm_device *dev,
 168                                       const struct of_endpoint *ep)
 169 {
 170         struct device_node *np;
 171         void *obj;
 172
 173         np = of_graph_get_remote_port_parent(ep->local_node);
 174
 175         obj = of_drm_find_panel(np);
 176         if (!obj)
 177                 obj = of_drm_find_bridge(np);
 178
 179         of_node_put(np);
 180
 181         return obj ? 0 : -EPROBE_DEFER;
 182 }
 183
 184 static int atmel_hlcdc_attach_endpoint(struct drm_device *dev,
 185                                        const struct of_endpoint *ep)
 186 {
 187         struct atmel_hlcdc_dc *dc = dev->dev_private;
 188         struct atmel_hlcdc_rgb_output *output;
 189         struct device_node *np;
 190         struct drm_panel *panel;
 191         struct drm_bridge *bridge;
 192         int ret;
 193
 194         output = devm_kzalloc(dev->dev, sizeof(*output), GFP_KERNEL);
 195         if (!output)
 196                 return -EINVAL;
 197
 198         output->dc = dc;
 199
 200         drm_encoder_helper_add(&output->encoder,
 201                                &atmel_hlcdc_panel_encoder_helper_funcs);
 202         ret = drm_encoder_init(dev, &output->encoder,
 203                                &atmel_hlcdc_panel_encoder_funcs,
 204                                DRM_MODE_ENCODER_NONE, NULL);
 205         if (ret)
 206                 return ret;
 207
 208         output->encoder.possible_crtcs = 0x1;
 209
 210         np = of_graph_get_remote_port_parent(ep->local_node);
 211
 212         ret = -EPROBE_DEFER;
 213
 214         panel = of_drm_find_panel(np);
 215         if (panel) {
 216                 of_node_put(np);
 217                 output->connector.dpms = DRM_MODE_DPMS_OFF;
 218                 output->connector.polled = DRM_CONNECTOR_POLL_CONNECT;
 219                 drm_connector_helper_add(&output->connector,
 220                                 &atmel_hlcdc_panel_connector_helper_funcs);
 221                 ret = drm_connector_init(dev, &output->connector,
 222                                          &atmel_hlcdc_panel_connector_funcs,
 223                                          DRM_MODE_CONNECTOR_Unknown);
 224                 if (ret)
 225                         goto err_encoder_cleanup;
 226
 227                 drm_mode_connector_attach_encoder(&output->connector,
 228                                                   &output->encoder);
 229
 230                 ret = drm_panel_attach(panel, &output->connector);
 231                 if (ret) {
 232                         drm_connector_cleanup(&output->connector);
 233                         goto err_encoder_cleanup;
 234                 }
 235
 236                 output->panel = panel;
 237
 238                 return 0;
 239         }
 240
 241         bridge = of_drm_find_bridge(np);
 242         of_node_put(np);
 243
 244         if (bridge) {
 245                 output->encoder.bridge = bridge;
 246                 bridge->encoder = &output->encoder;
 247                 ret = drm_bridge_attach(dev, bridge);
 248                 if (!ret)
 249                         return 0;
 250         }
 251
 252 err_encoder_cleanup:
 253         drm_encoder_cleanup(&output->encoder);
 254
 255         return ret;
 256 }
 257
 258 int atmel_hlcdc_create_outputs(struct drm_device *dev)
 259 {
 260         struct device_node *ep_np = NULL;
 261         struct of_endpoint ep;
 262         int ret;
 263
 264         for_each_endpoint_of_node(dev->dev->of_node, ep_np) {
 265                 ret = of_graph_parse_endpoint(ep_np, &ep);
 266                 if (!ret)
 267                         ret = atmel_hlcdc_check_endpoint(dev, &ep);
 268
 269                 if (ret) {
 270                         of_node_put(ep_np);
 271                         return ret;
 272                 }
 273         }
 274
 275         for_each_endpoint_of_node(dev->dev->of_node, ep_np) {
 276                 ret = of_graph_parse_endpoint(ep_np, &ep);
 277                 if (!ret)
 278                         ret = atmel_hlcdc_attach_endpoint(dev, &ep);
 279
 280                 if (ret) {
 281                         of_node_put(ep_np);
 282                         return ret;
 283                 }
 284         }
 285
 286         return 0;
 287 }