drivers/gpu/drm/exynos/exynos_drm_encoder.c

   1 /* exynos_drm_encoder.c
   2  *
   3  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
   4  * Authors:
   5  *      Inki Dae <inki.dae@samsung.com>
   6  *      Joonyoung Shim <jy0922.shim@samsung.com>
   7  *      Seung-Woo Kim <sw0312.kim@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the next
  17  * paragraph) shall be included in all copies or substantial portions of the
  18  * Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  24  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  25  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  26  * OTHER DEALINGS IN THE SOFTWARE.
  27  */
  28
  29 #include "drmP.h"
  30 #include "drm_crtc_helper.h"
  31
  32 #include "exynos_drm_drv.h"
  33 #include "exynos_drm_crtc.h"
  34 #include "exynos_drm_encoder.h"
  35
  36 #define to_exynos_encoder(x)    container_of(x, struct exynos_drm_encoder,\
  37                                 drm_encoder)
  38
  39 /*
  40  * exynos specific encoder structure.
  41  *
  42  * @drm_encoder: encoder object.
  43  * @manager: specific encoder has its own manager to control a hardware
  44  *      appropriately and we can access a hardware drawing on this manager.
  45  */
  46 struct exynos_drm_encoder {
  47         struct drm_encoder              drm_encoder;
  48         struct exynos_drm_manager       *manager;
  49 };
  50
  51 static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
  52 {
  53         struct drm_device *dev = encoder->dev;
  54         struct drm_connector *connector;
  55         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
  56
  57         DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode);
  58
  59         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  60                 if (connector->encoder == encoder) {
  61                         struct exynos_drm_display_ops *display_ops =
  62                                                         manager->display_ops;
  63
  64                         DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
  65                                         connector->base.id, mode);
  66                         if (display_ops && display_ops->power_on)
  67                                 display_ops->power_on(manager->dev, mode);
  68                 }
  69         }
  70 }
  71
  72 static bool
  73 exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
  74                                struct drm_display_mode *mode,
  75                                struct drm_display_mode *adjusted_mode)
  76 {
  77         DRM_DEBUG_KMS("%s\n", __FILE__);
  78
  79         /* drm framework doesn't check NULL. */
  80
  81         return true;
  82 }
  83
  84 static void exynos_drm_encoder_mode_set(struct drm_encoder *encoder,
  85                                          struct drm_display_mode *mode,
  86                                          struct drm_display_mode *adjusted_mode)
  87 {
  88         struct drm_device *dev = encoder->dev;
  89         struct drm_connector *connector;
  90         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
  91         struct exynos_drm_manager_ops *manager_ops = manager->ops;
  92         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
  93         struct exynos_drm_overlay *overlay = get_exynos_drm_overlay(dev,
  94                                                 encoder->crtc);
  95
  96         DRM_DEBUG_KMS("%s\n", __FILE__);
  97
  98         mode = adjusted_mode;
  99
 100         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 101                 if (connector->encoder == encoder) {
 102                         if (manager_ops && manager_ops->mode_set)
 103                                 manager_ops->mode_set(manager->dev, mode);
 104
 105                         if (overlay_ops && overlay_ops->mode_set)
 106                                 overlay_ops->mode_set(manager->dev, overlay);
 107                 }
 108         }
 109 }
 110
 111 static void exynos_drm_encoder_prepare(struct drm_encoder *encoder)
 112 {
 113         DRM_DEBUG_KMS("%s\n", __FILE__);
 114
 115         /* drm framework doesn't check NULL. */
 116 }
 117
 118 static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
 119 {
 120         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
 121         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 122
 123         DRM_DEBUG_KMS("%s\n", __FILE__);
 124
 125         if (manager_ops && manager_ops->commit)
 126                 manager_ops->commit(manager->dev);
 127 }
 128
 129 static struct drm_crtc *
 130 exynos_drm_encoder_get_crtc(struct drm_encoder *encoder)
 131 {
 132         return encoder->crtc;
 133 }
 134
 135 static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs = {
 136         .dpms           = exynos_drm_encoder_dpms,
 137         .mode_fixup     = exynos_drm_encoder_mode_fixup,
 138         .mode_set       = exynos_drm_encoder_mode_set,
 139         .prepare        = exynos_drm_encoder_prepare,
 140         .commit         = exynos_drm_encoder_commit,
 141         .get_crtc       = exynos_drm_encoder_get_crtc,
 142 };
 143
 144 static void exynos_drm_encoder_destroy(struct drm_encoder *encoder)
 145 {
 146         struct exynos_drm_encoder *exynos_encoder =
 147                 to_exynos_encoder(encoder);
 148
 149         DRM_DEBUG_KMS("%s\n", __FILE__);
 150
 151         exynos_encoder->manager->pipe = -1;
 152
 153         drm_encoder_cleanup(encoder);
 154         encoder->dev->mode_config.num_encoder--;
 155         kfree(exynos_encoder);
 156 }
 157
 158 static struct drm_encoder_funcs exynos_encoder_funcs = {
 159         .destroy = exynos_drm_encoder_destroy,
 160 };
 161
 162 struct drm_encoder *
 163 exynos_drm_encoder_create(struct drm_device *dev,
 164                            struct exynos_drm_manager *manager,
 165                            unsigned int possible_crtcs)
 166 {
 167         struct drm_encoder *encoder;
 168         struct exynos_drm_encoder *exynos_encoder;
 169
 170         DRM_DEBUG_KMS("%s\n", __FILE__);
 171
 172         if (!manager || !possible_crtcs)
 173                 return NULL;
 174
 175         if (!manager->dev)
 176                 return NULL;
 177
 178         exynos_encoder = kzalloc(sizeof(*exynos_encoder), GFP_KERNEL);
 179         if (!exynos_encoder) {
 180                 DRM_ERROR("failed to allocate encoder\n");
 181                 return NULL;
 182         }
 183
 184         exynos_encoder->manager = manager;
 185         encoder = &exynos_encoder->drm_encoder;
 186         encoder->possible_crtcs = possible_crtcs;
 187
 188         DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 189
 190         drm_encoder_init(dev, encoder, &exynos_encoder_funcs,
 191                         DRM_MODE_ENCODER_TMDS);
 192
 193         drm_encoder_helper_add(encoder, &exynos_encoder_helper_funcs);
 194
 195         DRM_DEBUG_KMS("encoder has been created\n");
 196
 197         return encoder;
 198 }
 199
 200 struct exynos_drm_manager *exynos_drm_get_manager(struct drm_encoder *encoder)
 201 {
 202         return to_exynos_encoder(encoder)->manager;
 203 }
 204
 205 void exynos_drm_fn_encoder(struct drm_crtc *crtc, void *data,
 206                             void (*fn)(struct drm_encoder *, void *))
 207 {
 208         struct drm_device *dev = crtc->dev;
 209         struct drm_encoder *encoder;
 210         struct exynos_drm_private *private = dev->dev_private;
 211         struct exynos_drm_manager *manager;
 212
 213         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 214                 /*
 215                  * if crtc is detached from encoder, check pipe,
 216                  * otherwise check crtc attached to encoder
 217                  */
 218                 if (!encoder->crtc) {
 219                         manager = to_exynos_encoder(encoder)->manager;
 220                         if (manager->pipe < 0 ||
 221                                         private->crtc[manager->pipe] != crtc)
 222                                 continue;
 223                 } else {
 224                         if (encoder->crtc != crtc)
 225                                 continue;
 226                 }
 227
 228                 fn(encoder, data);
 229         }
 230 }
 231
 232 void exynos_drm_enable_vblank(struct drm_encoder *encoder, void *data)
 233 {
 234         struct exynos_drm_manager *manager =
 235                 to_exynos_encoder(encoder)->manager;
 236         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 237         int crtc = *(int *)data;
 238
 239         if (manager->pipe == -1)
 240                 manager->pipe = crtc;
 241
 242         if (manager_ops->enable_vblank)
 243                 manager_ops->enable_vblank(manager->dev);
 244 }
 245
 246 void exynos_drm_disable_vblank(struct drm_encoder *encoder, void *data)
 247 {
 248         struct exynos_drm_manager *manager =
 249                 to_exynos_encoder(encoder)->manager;
 250         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 251         int crtc = *(int *)data;
 252
 253         if (manager->pipe == -1)
 254                 manager->pipe = crtc;
 255
 256         if (manager_ops->disable_vblank)
 257                 manager_ops->disable_vblank(manager->dev);
 258 }
 259
 260 void exynos_drm_encoder_crtc_commit(struct drm_encoder *encoder, void *data)
 261 {
 262         struct exynos_drm_manager *manager =
 263                 to_exynos_encoder(encoder)->manager;
 264         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 265         int crtc = *(int *)data;
 266
 267         DRM_DEBUG_KMS("%s\n", __FILE__);
 268
 269         /*
 270          * when crtc is detached from encoder, this pipe is used
 271          * to select manager operation
 272          */
 273         manager->pipe = crtc;
 274
 275         if (overlay_ops && overlay_ops->commit)
 276                 overlay_ops->commit(manager->dev);
 277 }
 278
 279 void exynos_drm_encoder_crtc_mode_set(struct drm_encoder *encoder, void *data)
 280 {
 281         struct exynos_drm_manager *manager =
 282                 to_exynos_encoder(encoder)->manager;
 283         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 284         struct exynos_drm_overlay *overlay = data;
 285
 286         if (overlay_ops && overlay_ops->mode_set)
 287                 overlay_ops->mode_set(manager->dev, overlay);
 288 }
 289
 290 void exynos_drm_encoder_crtc_disable(struct drm_encoder *encoder, void *data)
 291 {
 292         struct exynos_drm_manager *manager =
 293                 to_exynos_encoder(encoder)->manager;
 294         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 295
 296         DRM_DEBUG_KMS("\n");
 297
 298         if (overlay_ops && overlay_ops->disable)
 299                 overlay_ops->disable(manager->dev);
 300
 301         /*
 302          * crtc is already detached from encoder and last
 303          * function for detaching is properly done, so
 304          * clear pipe from manager to prevent repeated call
 305          */
 306         if (!encoder->crtc)
 307                 manager->pipe = -1;
 308 }
 309
 310 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
 311 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
 312 MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
 313 MODULE_DESCRIPTION("Samsung SoC DRM Encoder Driver");
 314 MODULE_LICENSE("GPL");