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 output mode
  31  */
  32 enum atmel_hlcdc_connector_rgb_mode {
  33         ATMEL_HLCDC_CONNECTOR_RGB444,
  34         ATMEL_HLCDC_CONNECTOR_RGB565,
  35         ATMEL_HLCDC_CONNECTOR_RGB666,
  36         ATMEL_HLCDC_CONNECTOR_RGB888,
  37 };
  38
  39 /**
  40  * Atmel HLCDC RGB connector structure
  41  *
  42  * This structure stores RGB slave device information.
  43  *
  44  * @connector: DRM connector
  45  * @encoder: DRM encoder
  46  * @dc: pointer to the atmel_hlcdc_dc structure
  47  * @dpms: current DPMS mode
  48  */
  49 struct atmel_hlcdc_rgb_output {
  50         struct drm_connector connector;
  51         struct drm_encoder encoder;
  52         struct atmel_hlcdc_dc *dc;
  53         int dpms;
  54 };
  55
  56 static inline struct atmel_hlcdc_rgb_output *
  57 drm_connector_to_atmel_hlcdc_rgb_output(struct drm_connector *connector)
  58 {
  59         return container_of(connector, struct atmel_hlcdc_rgb_output,
  60                             connector);
  61 }
  62
  63 static inline struct atmel_hlcdc_rgb_output *
  64 drm_encoder_to_atmel_hlcdc_rgb_output(struct drm_encoder *encoder)
  65 {
  66         return container_of(encoder, struct atmel_hlcdc_rgb_output, encoder);
  67 }
  68
  69 /**
  70  * Atmel HLCDC Panel device structure
  71  *
  72  * This structure is specialization of the slave device structure to
  73  * interface with drm panels.
  74  *
  75  * @base: base slave device fields
  76  * @panel: drm panel attached to this slave device
  77  */
  78 struct atmel_hlcdc_panel {
  79         struct atmel_hlcdc_rgb_output base;
  80         struct drm_panel *panel;
  81 };
  82
  83 static inline struct atmel_hlcdc_panel *
  84 atmel_hlcdc_rgb_output_to_panel(struct atmel_hlcdc_rgb_output *output)
  85 {
  86         return container_of(output, struct atmel_hlcdc_panel, base);
  87 }
  88
  89 static void atmel_hlcdc_panel_encoder_dpms(struct drm_encoder *encoder,
  90                                            int mode)
  91 {
  92         struct atmel_hlcdc_rgb_output *rgb =
  93                         drm_encoder_to_atmel_hlcdc_rgb_output(encoder);
  94         struct atmel_hlcdc_panel *panel = atmel_hlcdc_rgb_output_to_panel(rgb);
  95
  96         if (mode != DRM_MODE_DPMS_ON)
  97                 mode = DRM_MODE_DPMS_OFF;
  98
  99         if (mode == rgb->dpms)
 100                 return;
 101
 102         if (mode != DRM_MODE_DPMS_ON)
 103                 drm_panel_disable(panel->panel);
 104         else
 105                 drm_panel_enable(panel->panel);
 106
 107         rgb->dpms = mode;
 108 }
 109
 110 static bool
 111 atmel_hlcdc_panel_encoder_mode_fixup(struct drm_encoder *encoder,
 112                                      const struct drm_display_mode *mode,
 113                                      struct drm_display_mode *adjusted)
 114 {
 115         return true;
 116 }
 117
 118 static void atmel_hlcdc_panel_encoder_prepare(struct drm_encoder *encoder)
 119 {
 120         atmel_hlcdc_panel_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
 121 }
 122
 123 static void atmel_hlcdc_panel_encoder_commit(struct drm_encoder *encoder)
 124 {
 125         atmel_hlcdc_panel_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
 126 }
 127
 128 static void
 129 atmel_hlcdc_rgb_encoder_mode_set(struct drm_encoder *encoder,
 130                                  struct drm_display_mode *mode,
 131                                  struct drm_display_mode *adjusted)
 132 {
 133         struct atmel_hlcdc_rgb_output *rgb =
 134                         drm_encoder_to_atmel_hlcdc_rgb_output(encoder);
 135         struct drm_display_info *info = &rgb->connector.display_info;
 136         unsigned int cfg;
 137
 138         cfg = 0;
 139
 140         if (info->num_bus_formats) {
 141                 switch (info->bus_formats[0]) {
 142                 case MEDIA_BUS_FMT_RGB666_1X18:
 143                         cfg |= ATMEL_HLCDC_CONNECTOR_RGB666 << 8;
 144                         break;
 145                 case MEDIA_BUS_FMT_RGB888_1X24:
 146                         cfg |= ATMEL_HLCDC_CONNECTOR_RGB888 << 8;
 147                         break;
 148                 default:
 149                         break;
 150                 }
 151         }
 152
 153         regmap_update_bits(rgb->dc->hlcdc->regmap, ATMEL_HLCDC_CFG(5),
 154                            ATMEL_HLCDC_MODE_MASK,
 155                            cfg);
 156 }
 157
 158 static struct drm_encoder_helper_funcs atmel_hlcdc_panel_encoder_helper_funcs = {
 159         .dpms = atmel_hlcdc_panel_encoder_dpms,
 160         .mode_fixup = atmel_hlcdc_panel_encoder_mode_fixup,
 161         .prepare = atmel_hlcdc_panel_encoder_prepare,
 162         .commit = atmel_hlcdc_panel_encoder_commit,
 163         .mode_set = atmel_hlcdc_rgb_encoder_mode_set,
 164 };
 165
 166 static void atmel_hlcdc_rgb_encoder_destroy(struct drm_encoder *encoder)
 167 {
 168         drm_encoder_cleanup(encoder);
 169         memset(encoder, 0, sizeof(*encoder));
 170 }
 171
 172 static const struct drm_encoder_funcs atmel_hlcdc_panel_encoder_funcs = {
 173         .destroy = atmel_hlcdc_rgb_encoder_destroy,
 174 };
 175
 176 static int atmel_hlcdc_panel_get_modes(struct drm_connector *connector)
 177 {
 178         struct atmel_hlcdc_rgb_output *rgb =
 179                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 180         struct atmel_hlcdc_panel *panel = atmel_hlcdc_rgb_output_to_panel(rgb);
 181
 182         return panel->panel->funcs->get_modes(panel->panel);
 183 }
 184
 185 static int atmel_hlcdc_rgb_mode_valid(struct drm_connector *connector,
 186                                       struct drm_display_mode *mode)
 187 {
 188         struct atmel_hlcdc_rgb_output *rgb =
 189                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 190
 191         return atmel_hlcdc_dc_mode_valid(rgb->dc, mode);
 192 }
 193
 194
 195
 196 static struct drm_encoder *
 197 atmel_hlcdc_rgb_best_encoder(struct drm_connector *connector)
 198 {
 199         struct atmel_hlcdc_rgb_output *rgb =
 200                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 201
 202         return &rgb->encoder;
 203 }
 204
 205 static struct drm_connector_helper_funcs atmel_hlcdc_panel_connector_helper_funcs = {
 206         .get_modes = atmel_hlcdc_panel_get_modes,
 207         .mode_valid = atmel_hlcdc_rgb_mode_valid,
 208         .best_encoder = atmel_hlcdc_rgb_best_encoder,
 209 };
 210
 211 static enum drm_connector_status
 212 atmel_hlcdc_panel_connector_detect(struct drm_connector *connector, bool force)
 213 {
 214         return connector_status_connected;
 215 }
 216
 217 static void
 218 atmel_hlcdc_panel_connector_destroy(struct drm_connector *connector)
 219 {
 220         struct atmel_hlcdc_rgb_output *rgb =
 221                         drm_connector_to_atmel_hlcdc_rgb_output(connector);
 222         struct atmel_hlcdc_panel *panel = atmel_hlcdc_rgb_output_to_panel(rgb);
 223
 224         drm_panel_detach(panel->panel);
 225         drm_connector_cleanup(connector);
 226 }
 227
 228 static const struct drm_connector_funcs atmel_hlcdc_panel_connector_funcs = {
 229         .dpms = drm_helper_connector_dpms,
 230         .detect = atmel_hlcdc_panel_connector_detect,
 231         .fill_modes = drm_helper_probe_single_connector_modes,
 232         .destroy = atmel_hlcdc_panel_connector_destroy,
 233 };
 234
 235 static int atmel_hlcdc_create_panel_output(struct drm_device *dev,
 236                                            struct of_endpoint *ep)
 237 {
 238         struct atmel_hlcdc_dc *dc = dev->dev_private;
 239         struct device_node *np;
 240         struct drm_panel *p = NULL;
 241         struct atmel_hlcdc_panel *panel;
 242         int ret;
 243
 244         np = of_graph_get_remote_port_parent(ep->local_node);
 245         if (!np)
 246                 return -EINVAL;
 247
 248         p = of_drm_find_panel(np);
 249         of_node_put(np);
 250
 251         if (!p)
 252                 return -EPROBE_DEFER;
 253
 254         panel = devm_kzalloc(dev->dev, sizeof(*panel), GFP_KERNEL);
 255         if (!panel)
 256                 return -EINVAL;
 257
 258         panel->base.dpms = DRM_MODE_DPMS_OFF;
 259
 260         panel->base.dc = dc;
 261
 262         drm_encoder_helper_add(&panel->base.encoder,
 263                                &atmel_hlcdc_panel_encoder_helper_funcs);
 264         ret = drm_encoder_init(dev, &panel->base.encoder,
 265                                &atmel_hlcdc_panel_encoder_funcs,
 266                                DRM_MODE_ENCODER_LVDS);
 267         if (ret)
 268                 return ret;
 269
 270         panel->base.connector.dpms = DRM_MODE_DPMS_OFF;
 271         panel->base.connector.polled = DRM_CONNECTOR_POLL_CONNECT;
 272         drm_connector_helper_add(&panel->base.connector,
 273                                  &atmel_hlcdc_panel_connector_helper_funcs);
 274         ret = drm_connector_init(dev, &panel->base.connector,
 275                                  &atmel_hlcdc_panel_connector_funcs,
 276                                  DRM_MODE_CONNECTOR_LVDS);
 277         if (ret)
 278                 goto err_encoder_cleanup;
 279
 280         drm_mode_connector_attach_encoder(&panel->base.connector,
 281                                           &panel->base.encoder);
 282         panel->base.encoder.possible_crtcs = 0x1;
 283
 284         drm_panel_attach(p, &panel->base.connector);
 285         panel->panel = p;
 286
 287         return 0;
 288
 289 err_encoder_cleanup:
 290         drm_encoder_cleanup(&panel->base.encoder);
 291
 292         return ret;
 293 }
 294
 295 int atmel_hlcdc_create_outputs(struct drm_device *dev)
 296 {
 297         struct device_node *port_np, *np;
 298         struct of_endpoint ep;
 299         int ret;
 300
 301         port_np = of_get_child_by_name(dev->dev->of_node, "port");
 302         if (!port_np)
 303                 return -EINVAL;
 304
 305         np = of_get_child_by_name(port_np, "endpoint");
 306         of_node_put(port_np);
 307
 308         if (!np)
 309                 return -EINVAL;
 310
 311         ret = of_graph_parse_endpoint(np, &ep);
 312         of_node_put(port_np);
 313
 314         if (ret)
 315                 return ret;
 316
 317         /* We currently only support panel output */
 318         return atmel_hlcdc_create_panel_output(dev, &ep);
 319 }