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 <drm/drmP.h>
  30 #include <drm/drm_crtc_helper.h>
  31
  32 #include "exynos_drm_drv.h"
  33 #include "exynos_drm_encoder.h"
  34 #include "exynos_drm_connector.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  * @dpms: store the encoder dpms value.
  46  * @updated: indicate whether overlay data updating is needed or not.
  47  */
  48 struct exynos_drm_encoder {
  49         struct drm_crtc                 *old_crtc;
  50         struct drm_encoder              drm_encoder;
  51         struct exynos_drm_manager       *manager;
  52         int                             dpms;
  53         bool                            updated;
  54 };
  55
  56 static void exynos_drm_connector_power(struct drm_encoder *encoder, int mode)
  57 {
  58         struct drm_device *dev = encoder->dev;
  59         struct drm_connector *connector;
  60
  61         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  62                 if (exynos_drm_best_encoder(connector) == encoder) {
  63                         DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
  64                                         connector->base.id, mode);
  65
  66                         exynos_drm_display_power(connector, 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                         if (!exynos_encoder->updated)
  91                                 manager_ops->apply(manager->dev);
  92
  93                 exynos_drm_connector_power(encoder, mode);
  94                 exynos_encoder->dpms = mode;
  95                 break;
  96         case DRM_MODE_DPMS_STANDBY:
  97         case DRM_MODE_DPMS_SUSPEND:
  98         case DRM_MODE_DPMS_OFF:
  99                 exynos_drm_connector_power(encoder, mode);
 100                 exynos_encoder->dpms = mode;
 101                 exynos_encoder->updated = false;
 102                 break;
 103         default:
 104                 DRM_ERROR("unspecified mode %d\n", mode);
 105                 break;
 106         }
 107
 108         mutex_unlock(&dev->struct_mutex);
 109 }
 110
 111 static bool
 112 exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
 113                                const struct drm_display_mode *mode,
 114                                struct drm_display_mode *adjusted_mode)
 115 {
 116         struct drm_device *dev = encoder->dev;
 117         struct drm_connector *connector;
 118         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
 119         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 120
 121         DRM_DEBUG_KMS("%s\n", __FILE__);
 122
 123         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 124                 if (connector->encoder == encoder)
 125                         if (manager_ops && manager_ops->mode_fixup)
 126                                 manager_ops->mode_fixup(manager->dev, connector,
 127                                                         mode, adjusted_mode);
 128         }
 129
 130         return true;
 131 }
 132
 133 static void disable_plane_to_crtc(struct drm_device *dev,
 134                                                 struct drm_crtc *old_crtc,
 135                                                 struct drm_crtc *new_crtc)
 136 {
 137         struct drm_plane *plane;
 138
 139         /*
 140          * if old_crtc isn't same as encoder->crtc then it means that
 141          * user changed crtc id to another one so the plane to old_crtc
 142          * should be disabled and plane->crtc should be set to new_crtc
 143          * (encoder->crtc)
 144          */
 145         list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
 146                 if (plane->crtc == old_crtc) {
 147                         /*
 148                          * do not change below call order.
 149                          *
 150                          * plane->funcs->disable_plane call checks
 151                          * if encoder->crtc is same as plane->crtc and if same
 152                          * then overlay_ops->disable callback will be called
 153                          * to diasble current hw overlay so plane->crtc should
 154                          * have new_crtc because new_crtc was set to
 155                          * encoder->crtc in advance.
 156                          */
 157                         plane->crtc = new_crtc;
 158                         plane->funcs->disable_plane(plane);
 159                 }
 160         }
 161 }
 162
 163 static void exynos_drm_encoder_mode_set(struct drm_encoder *encoder,
 164                                          struct drm_display_mode *mode,
 165                                          struct drm_display_mode *adjusted_mode)
 166 {
 167         struct drm_device *dev = encoder->dev;
 168         struct drm_connector *connector;
 169         struct exynos_drm_manager *manager;
 170         struct exynos_drm_manager_ops *manager_ops;
 171
 172         DRM_DEBUG_KMS("%s\n", __FILE__);
 173
 174         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 175                 if (connector->encoder == encoder) {
 176                         struct exynos_drm_encoder *exynos_encoder;
 177
 178                         exynos_encoder = to_exynos_encoder(encoder);
 179
 180                         if (exynos_encoder->old_crtc != encoder->crtc &&
 181                                         exynos_encoder->old_crtc) {
 182
 183                                 /*
 184                                  * disable a plane to old crtc and change
 185                                  * crtc of the plane to new one.
 186                                  */
 187                                 disable_plane_to_crtc(dev,
 188                                                 exynos_encoder->old_crtc,
 189                                                 encoder->crtc);
 190                         }
 191
 192                         manager = exynos_drm_get_manager(encoder);
 193                         manager_ops = manager->ops;
 194
 195                         if (manager_ops && manager_ops->mode_set)
 196                                 manager_ops->mode_set(manager->dev,
 197                                                         adjusted_mode);
 198
 199                         exynos_encoder->old_crtc = encoder->crtc;
 200                 }
 201         }
 202 }
 203
 204 static void exynos_drm_encoder_prepare(struct drm_encoder *encoder)
 205 {
 206         DRM_DEBUG_KMS("%s\n", __FILE__);
 207
 208         /* drm framework doesn't check NULL. */
 209 }
 210
 211 static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
 212 {
 213         struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
 214         struct exynos_drm_manager *manager = exynos_encoder->manager;
 215         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 216
 217         DRM_DEBUG_KMS("%s\n", __FILE__);
 218
 219         if (manager_ops && manager_ops->commit)
 220                 manager_ops->commit(manager->dev);
 221
 222         /*
 223          * this will avoid one issue that overlay data is updated to
 224          * real hardware two times.
 225          * And this variable will be used to check if the data was
 226          * already updated or not by exynos_drm_encoder_dpms function.
 227          */
 228         exynos_encoder->updated = true;
 229 }
 230
 231 static void exynos_drm_encoder_disable(struct drm_encoder *encoder)
 232 {
 233         struct drm_plane *plane;
 234         struct drm_device *dev = encoder->dev;
 235
 236         exynos_drm_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
 237
 238         /* all planes connected to this encoder should be also disabled. */
 239         list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
 240                 if (plane->crtc == encoder->crtc)
 241                         plane->funcs->disable_plane(plane);
 242         }
 243 }
 244
 245 static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs = {
 246         .dpms           = exynos_drm_encoder_dpms,
 247         .mode_fixup     = exynos_drm_encoder_mode_fixup,
 248         .mode_set       = exynos_drm_encoder_mode_set,
 249         .prepare        = exynos_drm_encoder_prepare,
 250         .commit         = exynos_drm_encoder_commit,
 251         .disable        = exynos_drm_encoder_disable,
 252 };
 253
 254 static void exynos_drm_encoder_destroy(struct drm_encoder *encoder)
 255 {
 256         struct exynos_drm_encoder *exynos_encoder =
 257                 to_exynos_encoder(encoder);
 258
 259         DRM_DEBUG_KMS("%s\n", __FILE__);
 260
 261         exynos_encoder->manager->pipe = -1;
 262
 263         drm_encoder_cleanup(encoder);
 264         kfree(exynos_encoder);
 265 }
 266
 267 static struct drm_encoder_funcs exynos_encoder_funcs = {
 268         .destroy = exynos_drm_encoder_destroy,
 269 };
 270
 271 static unsigned int exynos_drm_encoder_clones(struct drm_encoder *encoder)
 272 {
 273         struct drm_encoder *clone;
 274         struct drm_device *dev = encoder->dev;
 275         struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
 276         struct exynos_drm_display_ops *display_ops =
 277                                 exynos_encoder->manager->display_ops;
 278         unsigned int clone_mask = 0;
 279         int cnt = 0;
 280
 281         list_for_each_entry(clone, &dev->mode_config.encoder_list, head) {
 282                 switch (display_ops->type) {
 283                 case EXYNOS_DISPLAY_TYPE_LCD:
 284                 case EXYNOS_DISPLAY_TYPE_HDMI:
 285                 case EXYNOS_DISPLAY_TYPE_VIDI:
 286                         clone_mask |= (1 << (cnt++));
 287                         break;
 288                 default:
 289                         continue;
 290                 }
 291         }
 292
 293         return clone_mask;
 294 }
 295
 296 void exynos_drm_encoder_setup(struct drm_device *dev)
 297 {
 298         struct drm_encoder *encoder;
 299
 300         DRM_DEBUG_KMS("%s\n", __FILE__);
 301
 302         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
 303                 encoder->possible_clones = exynos_drm_encoder_clones(encoder);
 304 }
 305
 306 struct drm_encoder *
 307 exynos_drm_encoder_create(struct drm_device *dev,
 308                            struct exynos_drm_manager *manager,
 309                            unsigned int possible_crtcs)
 310 {
 311         struct drm_encoder *encoder;
 312         struct exynos_drm_encoder *exynos_encoder;
 313
 314         DRM_DEBUG_KMS("%s\n", __FILE__);
 315
 316         if (!manager || !possible_crtcs)
 317                 return NULL;
 318
 319         if (!manager->dev)
 320                 return NULL;
 321
 322         exynos_encoder = kzalloc(sizeof(*exynos_encoder), GFP_KERNEL);
 323         if (!exynos_encoder) {
 324                 DRM_ERROR("failed to allocate encoder\n");
 325                 return NULL;
 326         }
 327
 328         exynos_encoder->dpms = DRM_MODE_DPMS_OFF;
 329         exynos_encoder->manager = manager;
 330         encoder = &exynos_encoder->drm_encoder;
 331         encoder->possible_crtcs = possible_crtcs;
 332
 333         DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 334
 335         drm_encoder_init(dev, encoder, &exynos_encoder_funcs,
 336                         DRM_MODE_ENCODER_TMDS);
 337
 338         drm_encoder_helper_add(encoder, &exynos_encoder_helper_funcs);
 339
 340         DRM_DEBUG_KMS("encoder has been created\n");
 341
 342         return encoder;
 343 }
 344
 345 struct exynos_drm_manager *exynos_drm_get_manager(struct drm_encoder *encoder)
 346 {
 347         return to_exynos_encoder(encoder)->manager;
 348 }
 349
 350 void exynos_drm_fn_encoder(struct drm_crtc *crtc, void *data,
 351                             void (*fn)(struct drm_encoder *, void *))
 352 {
 353         struct drm_device *dev = crtc->dev;
 354         struct drm_encoder *encoder;
 355         struct exynos_drm_private *private = dev->dev_private;
 356         struct exynos_drm_manager *manager;
 357
 358         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 359                 /*
 360                  * if crtc is detached from encoder, check pipe,
 361                  * otherwise check crtc attached to encoder
 362                  */
 363                 if (!encoder->crtc) {
 364                         manager = to_exynos_encoder(encoder)->manager;
 365                         if (manager->pipe < 0 ||
 366                                         private->crtc[manager->pipe] != crtc)
 367                                 continue;
 368                 } else {
 369                         if (encoder->crtc != crtc)
 370                                 continue;
 371                 }
 372
 373                 fn(encoder, data);
 374         }
 375 }
 376
 377 void exynos_drm_enable_vblank(struct drm_encoder *encoder, void *data)
 378 {
 379         struct exynos_drm_manager *manager =
 380                 to_exynos_encoder(encoder)->manager;
 381         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 382         int crtc = *(int *)data;
 383
 384         if (manager->pipe != crtc)
 385                 return;
 386
 387         if (manager_ops->enable_vblank)
 388                 manager_ops->enable_vblank(manager->dev);
 389 }
 390
 391 void exynos_drm_disable_vblank(struct drm_encoder *encoder, void *data)
 392 {
 393         struct exynos_drm_manager *manager =
 394                 to_exynos_encoder(encoder)->manager;
 395         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 396         int crtc = *(int *)data;
 397
 398         if (manager->pipe != crtc)
 399                 return;
 400
 401         if (manager_ops->disable_vblank)
 402                 manager_ops->disable_vblank(manager->dev);
 403 }
 404
 405 void exynos_drm_encoder_crtc_dpms(struct drm_encoder *encoder, void *data)
 406 {
 407         struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
 408         struct exynos_drm_manager *manager = exynos_encoder->manager;
 409         struct exynos_drm_manager_ops *manager_ops = manager->ops;
 410         int mode = *(int *)data;
 411
 412         DRM_DEBUG_KMS("%s\n", __FILE__);
 413
 414         if (manager_ops && manager_ops->dpms)
 415                 manager_ops->dpms(manager->dev, mode);
 416
 417         /*
 418          * if this condition is ok then it means that the crtc is already
 419          * detached from encoder and last function for detaching is properly
 420          * done, so clear pipe from manager to prevent repeated call.
 421          */
 422         if (mode > DRM_MODE_DPMS_ON) {
 423                 if (!encoder->crtc)
 424                         manager->pipe = -1;
 425         }
 426 }
 427
 428 void exynos_drm_encoder_crtc_pipe(struct drm_encoder *encoder, void *data)
 429 {
 430         struct exynos_drm_manager *manager =
 431                 to_exynos_encoder(encoder)->manager;
 432         int pipe = *(int *)data;
 433
 434         DRM_DEBUG_KMS("%s\n", __FILE__);
 435
 436         /*
 437          * when crtc is detached from encoder, this pipe is used
 438          * to select manager operation
 439          */
 440         manager->pipe = pipe;
 441 }
 442
 443 void exynos_drm_encoder_plane_mode_set(struct drm_encoder *encoder, void *data)
 444 {
 445         struct exynos_drm_manager *manager =
 446                 to_exynos_encoder(encoder)->manager;
 447         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 448         struct exynos_drm_overlay *overlay = data;
 449
 450         DRM_DEBUG_KMS("%s\n", __FILE__);
 451
 452         if (overlay_ops && overlay_ops->mode_set)
 453                 overlay_ops->mode_set(manager->dev, overlay);
 454 }
 455
 456 void exynos_drm_encoder_plane_commit(struct drm_encoder *encoder, void *data)
 457 {
 458         struct exynos_drm_manager *manager =
 459                 to_exynos_encoder(encoder)->manager;
 460         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 461         int zpos = DEFAULT_ZPOS;
 462
 463         DRM_DEBUG_KMS("%s\n", __FILE__);
 464
 465         if (data)
 466                 zpos = *(int *)data;
 467
 468         if (overlay_ops && overlay_ops->commit)
 469                 overlay_ops->commit(manager->dev, zpos);
 470 }
 471
 472 void exynos_drm_encoder_plane_enable(struct drm_encoder *encoder, void *data)
 473 {
 474         struct exynos_drm_manager *manager =
 475                 to_exynos_encoder(encoder)->manager;
 476         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 477         int zpos = DEFAULT_ZPOS;
 478
 479         DRM_DEBUG_KMS("%s\n", __FILE__);
 480
 481         if (data)
 482                 zpos = *(int *)data;
 483
 484         if (overlay_ops && overlay_ops->enable)
 485                 overlay_ops->enable(manager->dev, zpos);
 486 }
 487
 488 void exynos_drm_encoder_plane_disable(struct drm_encoder *encoder, void *data)
 489 {
 490         struct exynos_drm_manager *manager =
 491                 to_exynos_encoder(encoder)->manager;
 492         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 493         int zpos = DEFAULT_ZPOS;
 494
 495         DRM_DEBUG_KMS("%s\n", __FILE__);
 496
 497         if (data)
 498                 zpos = *(int *)data;
 499
 500         if (overlay_ops && overlay_ops->disable)
 501                 overlay_ops->disable(manager->dev, zpos);
 502
 503         /*
 504          * wait for vblank interrupt
 505          * - this makes sure that hardware overlay is disabled to avoid
 506          * for the dma accesses to memory after gem buffer was released
 507          * because the setting for disabling the overlay will be updated
 508          * at vsync.
 509          */
 510         if (overlay_ops->wait_for_vblank)
 511                 overlay_ops->wait_for_vblank(manager->dev);
 512 }