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_encoder.h"
  34
  35 #define to_exynos_encoder(x)    container_of(x, struct exynos_drm_encoder,\
  36                                 drm_encoder)
  37
  38 /*
  39  * exynos specific encoder structure.
  40  *
  41  * @drm_encoder: encoder object.
  42  * @manager: specific encoder has its own manager to control a hardware
  43  *      appropriately and we can access a hardware drawing on this manager.
  44  * @dpms: store the encoder dpms value.
  45  */
  46 struct exynos_drm_encoder {
  47         struct drm_encoder              drm_encoder;
  48         struct exynos_drm_manager       *manager;
  49         int dpms;
  50 };
  51
  52 static void exynos_drm_display_power(struct drm_encoder *encoder, int mode)
  53 {
  54         struct drm_device *dev = encoder->dev;
  55         struct drm_connector *connector;
  56         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
  57
  58         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  59                 if (connector->encoder == encoder) {
  60                         struct exynos_drm_display_ops *display_ops =
  61                                                         manager->display_ops;
  62
  63                         DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
  64                                         connector->base.id, mode);
  65                         if (display_ops && display_ops->power_on)
  66                                 display_ops->power_on(manager->dev, mode);
  67                 }
  68         }
  69 }
  70
  71 static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
  72 {
  73         struct drm_device *dev = encoder->dev;
  74         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
  75         struct exynos_drm_manager_ops *manager_ops = manager->ops;
  76         struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
  77
  78         DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode);
  79
  80         if (exynos_encoder->dpms == mode) {
  81                 DRM_DEBUG_KMS("desired dpms mode is same as previous one.\n");
  82                 return;
  83         }
  84
  85         mutex_lock(&dev->struct_mutex);
  86
  87         switch (mode) {
  88         case DRM_MODE_DPMS_ON:
  89                 if (manager_ops && manager_ops->apply)
  90                         manager_ops->apply(manager->dev);
  91                 exynos_drm_display_power(encoder, mode);
  92                 exynos_encoder->dpms = mode;
  93                 break;
  94         case DRM_MODE_DPMS_STANDBY:
  95         case DRM_MODE_DPMS_SUSPEND:
  96         case DRM_MODE_DPMS_OFF:
  97                 exynos_drm_display_power(encoder, mode);
  98                 exynos_encoder->dpms = mode;
  99                 break;
 100         default:
 101                 DRM_ERROR("unspecified mode %d\n", mode);
 102                 break;
 103         }
 104
 105         mutex_unlock(&dev->struct_mutex);
 106 }
 107
 108 static bool
 109 exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
 110                                const struct drm_display_mode *mode,
 111                                struct drm_display_mode *adjusted_mode)
 112 {
 113         struct drm_device *dev = encoder->dev;
 114         struct drm_connector *connector;
 115         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
 116         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 117
 118         DRM_DEBUG_KMS("%s\n", __FILE__);
 119
 120         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 121                 if (connector->encoder == encoder)
 122                         if (manager_ops && manager_ops->mode_fixup)
 123                                 manager_ops->mode_fixup(manager->dev, connector,
 124                                                         mode, adjusted_mode);
 125         }
 126
 127         return true;
 128 }
 129
 130 static void exynos_drm_encoder_mode_set(struct drm_encoder *encoder,
 131                                          struct drm_display_mode *mode,
 132                                          struct drm_display_mode *adjusted_mode)
 133 {
 134         struct drm_device *dev = encoder->dev;
 135         struct drm_connector *connector;
 136         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
 137         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 138
 139         DRM_DEBUG_KMS("%s\n", __FILE__);
 140
 141         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 142                 if (connector->encoder == encoder)
 143                         if (manager_ops && manager_ops->mode_set)
 144                                 manager_ops->mode_set(manager->dev,
 145                                                         adjusted_mode);
 146         }
 147 }
 148
 149 static void exynos_drm_encoder_prepare(struct drm_encoder *encoder)
 150 {
 151         DRM_DEBUG_KMS("%s\n", __FILE__);
 152
 153         /* drm framework doesn't check NULL. */
 154 }
 155
 156 static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
 157 {
 158         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
 159         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 160
 161         DRM_DEBUG_KMS("%s\n", __FILE__);
 162
 163         if (manager_ops && manager_ops->commit)
 164                 manager_ops->commit(manager->dev);
 165 }
 166
 167 static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs = {
 168         .dpms           = exynos_drm_encoder_dpms,
 169         .mode_fixup     = exynos_drm_encoder_mode_fixup,
 170         .mode_set       = exynos_drm_encoder_mode_set,
 171         .prepare        = exynos_drm_encoder_prepare,
 172         .commit         = exynos_drm_encoder_commit,
 173 };
 174
 175 static void exynos_drm_encoder_destroy(struct drm_encoder *encoder)
 176 {
 177         struct exynos_drm_encoder *exynos_encoder =
 178                 to_exynos_encoder(encoder);
 179
 180         DRM_DEBUG_KMS("%s\n", __FILE__);
 181
 182         exynos_encoder->manager->pipe = -1;
 183
 184         drm_encoder_cleanup(encoder);
 185         kfree(exynos_encoder);
 186 }
 187
 188 static struct drm_encoder_funcs exynos_encoder_funcs = {
 189         .destroy = exynos_drm_encoder_destroy,
 190 };
 191
 192 static unsigned int exynos_drm_encoder_clones(struct drm_encoder *encoder)
 193 {
 194         struct drm_encoder *clone;
 195         struct drm_device *dev = encoder->dev;
 196         struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
 197         struct exynos_drm_display_ops *display_ops =
 198                                 exynos_encoder->manager->display_ops;
 199         unsigned int clone_mask = 0;
 200         int cnt = 0;
 201
 202         list_for_each_entry(clone, &dev->mode_config.encoder_list, head) {
 203                 switch (display_ops->type) {
 204                 case EXYNOS_DISPLAY_TYPE_LCD:
 205                 case EXYNOS_DISPLAY_TYPE_HDMI:
 206                 case EXYNOS_DISPLAY_TYPE_VIDI:
 207                         clone_mask |= (1 << (cnt++));
 208                         break;
 209                 default:
 210                         continue;
 211                 }
 212         }
 213
 214         return clone_mask;
 215 }
 216
 217 void exynos_drm_encoder_setup(struct drm_device *dev)
 218 {
 219         struct drm_encoder *encoder;
 220
 221         DRM_DEBUG_KMS("%s\n", __FILE__);
 222
 223         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
 224                 encoder->possible_clones = exynos_drm_encoder_clones(encoder);
 225 }
 226
 227 struct drm_encoder *
 228 exynos_drm_encoder_create(struct drm_device *dev,
 229                            struct exynos_drm_manager *manager,
 230                            unsigned int possible_crtcs)
 231 {
 232         struct drm_encoder *encoder;
 233         struct exynos_drm_encoder *exynos_encoder;
 234
 235         DRM_DEBUG_KMS("%s\n", __FILE__);
 236
 237         if (!manager || !possible_crtcs)
 238                 return NULL;
 239
 240         if (!manager->dev)
 241                 return NULL;
 242
 243         exynos_encoder = kzalloc(sizeof(*exynos_encoder), GFP_KERNEL);
 244         if (!exynos_encoder) {
 245                 DRM_ERROR("failed to allocate encoder\n");
 246                 return NULL;
 247         }
 248
 249         exynos_encoder->dpms = DRM_MODE_DPMS_OFF;
 250         exynos_encoder->manager = manager;
 251         encoder = &exynos_encoder->drm_encoder;
 252         encoder->possible_crtcs = possible_crtcs;
 253
 254         DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 255
 256         drm_encoder_init(dev, encoder, &exynos_encoder_funcs,
 257                         DRM_MODE_ENCODER_TMDS);
 258
 259         drm_encoder_helper_add(encoder, &exynos_encoder_helper_funcs);
 260
 261         DRM_DEBUG_KMS("encoder has been created\n");
 262
 263         return encoder;
 264 }
 265
 266 struct exynos_drm_manager *exynos_drm_get_manager(struct drm_encoder *encoder)
 267 {
 268         return to_exynos_encoder(encoder)->manager;
 269 }
 270
 271 void exynos_drm_fn_encoder(struct drm_crtc *crtc, void *data,
 272                             void (*fn)(struct drm_encoder *, void *))
 273 {
 274         struct drm_device *dev = crtc->dev;
 275         struct drm_encoder *encoder;
 276         struct exynos_drm_private *private = dev->dev_private;
 277         struct exynos_drm_manager *manager;
 278
 279         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 280                 /*
 281                  * if crtc is detached from encoder, check pipe,
 282                  * otherwise check crtc attached to encoder
 283                  */
 284                 if (!encoder->crtc) {
 285                         manager = to_exynos_encoder(encoder)->manager;
 286                         if (manager->pipe < 0 ||
 287                                         private->crtc[manager->pipe] != crtc)
 288                                 continue;
 289                 } else {
 290                         if (encoder->crtc != crtc)
 291                                 continue;
 292                 }
 293
 294                 fn(encoder, data);
 295         }
 296 }
 297
 298 void exynos_drm_enable_vblank(struct drm_encoder *encoder, void *data)
 299 {
 300         struct exynos_drm_manager *manager =
 301                 to_exynos_encoder(encoder)->manager;
 302         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 303         int crtc = *(int *)data;
 304
 305         if (manager->pipe != crtc)
 306                 return;
 307
 308         if (manager_ops->enable_vblank)
 309                 manager_ops->enable_vblank(manager->dev);
 310 }
 311
 312 void exynos_drm_disable_vblank(struct drm_encoder *encoder, void *data)
 313 {
 314         struct exynos_drm_manager *manager =
 315                 to_exynos_encoder(encoder)->manager;
 316         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 317         int crtc = *(int *)data;
 318
 319         if (manager->pipe != crtc)
 320                 return;
 321
 322         if (manager_ops->disable_vblank)
 323                 manager_ops->disable_vblank(manager->dev);
 324 }
 325
 326 void exynos_drm_encoder_dpms_from_crtc(struct drm_encoder *encoder, void *data)
 327 {
 328         struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
 329         int mode = *(int *)data;
 330
 331         DRM_DEBUG_KMS("%s\n", __FILE__);
 332
 333         exynos_drm_encoder_dpms(encoder, mode);
 334
 335         exynos_encoder->dpms = mode;
 336 }
 337
 338 void exynos_drm_encoder_crtc_dpms(struct drm_encoder *encoder, void *data)
 339 {
 340         struct drm_device *dev = encoder->dev;
 341         struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
 342         struct exynos_drm_manager *manager = exynos_encoder->manager;
 343         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 344         struct drm_connector *connector;
 345         int mode = *(int *)data;
 346
 347         DRM_DEBUG_KMS("%s\n", __FILE__);
 348
 349         if (manager_ops && manager_ops->dpms)
 350                 manager_ops->dpms(manager->dev, mode);
 351
 352         /*
 353          * set current dpms mode to the connector connected to
 354          * current encoder. connector->dpms would be checked
 355          * at drm_helper_connector_dpms()
 356          */
 357         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
 358                 if (connector->encoder == encoder)
 359                         connector->dpms = mode;
 360
 361         /*
 362          * if this condition is ok then it means that the crtc is already
 363          * detached from encoder and last function for detaching is properly
 364          * done, so clear pipe from manager to prevent repeated call.
 365          */
 366         if (mode > DRM_MODE_DPMS_ON) {
 367                 if (!encoder->crtc)
 368                         manager->pipe = -1;
 369         }
 370 }
 371
 372 void exynos_drm_encoder_crtc_pipe(struct drm_encoder *encoder, void *data)
 373 {
 374         struct exynos_drm_manager *manager =
 375                 to_exynos_encoder(encoder)->manager;
 376         int pipe = *(int *)data;
 377
 378         DRM_DEBUG_KMS("%s\n", __FILE__);
 379
 380         /*
 381          * when crtc is detached from encoder, this pipe is used
 382          * to select manager operation
 383          */
 384         manager->pipe = pipe;
 385 }
 386
 387 void exynos_drm_encoder_plane_mode_set(struct drm_encoder *encoder, void *data)
 388 {
 389         struct exynos_drm_manager *manager =
 390                 to_exynos_encoder(encoder)->manager;
 391         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 392         struct exynos_drm_overlay *overlay = data;
 393
 394         DRM_DEBUG_KMS("%s\n", __FILE__);
 395
 396         if (overlay_ops && overlay_ops->mode_set)
 397                 overlay_ops->mode_set(manager->dev, overlay);
 398 }
 399
 400 void exynos_drm_encoder_plane_commit(struct drm_encoder *encoder, void *data)
 401 {
 402         struct exynos_drm_manager *manager =
 403                 to_exynos_encoder(encoder)->manager;
 404         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 405         int zpos = DEFAULT_ZPOS;
 406
 407         DRM_DEBUG_KMS("%s\n", __FILE__);
 408
 409         if (data)
 410                 zpos = *(int *)data;
 411
 412         if (overlay_ops && overlay_ops->commit)
 413                 overlay_ops->commit(manager->dev, zpos);
 414 }
 415
 416 void exynos_drm_encoder_plane_disable(struct drm_encoder *encoder, void *data)
 417 {
 418         struct exynos_drm_manager *manager =
 419                 to_exynos_encoder(encoder)->manager;
 420         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 421         int zpos = DEFAULT_ZPOS;
 422
 423         DRM_DEBUG_KMS("%s\n", __FILE__);
 424
 425         if (data)
 426                 zpos = *(int *)data;
 427
 428         if (overlay_ops && overlay_ops->disable)
 429                 overlay_ops->disable(manager->dev, zpos);
 430 }