drivers/gpu/drm/exynos/exynos_drm_drv.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
   3  * Authors:
   4  *      Inki Dae <inki.dae@samsung.com>
   5  *      Joonyoung Shim <jy0922.shim@samsung.com>
   6  *      Seung-Woo Kim <sw0312.kim@samsung.com>
   7  *
   8  * This program is free software; you can redistribute  it and/or modify it
   9  * under  the terms of  the GNU General  Public License as published by the
  10  * Free Software Foundation;  either version 2 of the  License, or (at your
  11  * option) any later version.
  12  */
  13
  14 #include <linux/pm_runtime.h>
  15 #include <drm/drmP.h>
  16 #include <drm/drm_crtc_helper.h>
  17
  18 #include <linux/anon_inodes.h>
  19
  20 #include <drm/exynos_drm.h>
  21
  22 #include "exynos_drm_drv.h"
  23 #include "exynos_drm_crtc.h"
  24 #include "exynos_drm_encoder.h"
  25 #include "exynos_drm_fbdev.h"
  26 #include "exynos_drm_fb.h"
  27 #include "exynos_drm_gem.h"
  28 #include "exynos_drm_plane.h"
  29 #include "exynos_drm_vidi.h"
  30 #include "exynos_drm_dmabuf.h"
  31 #include "exynos_drm_g2d.h"
  32 #include "exynos_drm_ipp.h"
  33 #include "exynos_drm_iommu.h"
  34
  35 #define DRIVER_NAME     "exynos"
  36 #define DRIVER_DESC     "Samsung SoC DRM"
  37 #define DRIVER_DATE     "20110530"
  38 #define DRIVER_MAJOR    1
  39 #define DRIVER_MINOR    0
  40
  41 #define VBLANK_OFF_DELAY        50000
  42
  43 /* platform device pointer for eynos drm device. */
  44 static struct platform_device *exynos_drm_pdev;
  45
  46 static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
  47 {
  48         struct exynos_drm_private *private;
  49         int ret;
  50         int nr;
  51
  52         private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL);
  53         if (!private)
  54                 return -ENOMEM;
  55
  56         INIT_LIST_HEAD(&private->pageflip_event_list);
  57         dev_set_drvdata(dev->dev, dev);
  58         dev->dev_private = (void *)private;
  59
  60         /*
  61          * create mapping to manage iommu table and set a pointer to iommu
  62          * mapping structure to iommu_mapping of private data.
  63          * also this iommu_mapping can be used to check if iommu is supported
  64          * or not.
  65          */
  66         ret = drm_create_iommu_mapping(dev);
  67         if (ret < 0) {
  68                 DRM_ERROR("failed to create iommu mapping.\n");
  69                 goto err_free_private;
  70         }
  71
  72         drm_mode_config_init(dev);
  73
  74         /* init kms poll for handling hpd */
  75         drm_kms_helper_poll_init(dev);
  76
  77         exynos_drm_mode_config_init(dev);
  78
  79         ret = exynos_drm_initialize_managers(dev);
  80         if (ret)
  81                 goto err_mode_config_cleanup;
  82
  83         for (nr = 0; nr < MAX_PLANE; nr++) {
  84                 struct drm_plane *plane;
  85                 unsigned long possible_crtcs = (1 << MAX_CRTC) - 1;
  86
  87                 plane = exynos_plane_init(dev, possible_crtcs, false);
  88                 if (!plane)
  89                         goto err_manager_cleanup;
  90         }
  91
  92         ret = exynos_drm_initialize_displays(dev);
  93         if (ret)
  94                 goto err_manager_cleanup;
  95
  96         ret = drm_vblank_init(dev, MAX_CRTC);
  97         if (ret)
  98                 goto err_display_cleanup;
  99
 100         /*
 101          * probe sub drivers such as display controller and hdmi driver,
 102          * that were registered at probe() of platform driver
 103          * to the sub driver and create encoder and connector for them.
 104          */
 105         ret = exynos_drm_device_register(dev);
 106         if (ret)
 107                 goto err_vblank;
 108
 109         /* setup possible_clones. */
 110         exynos_drm_encoder_setup(dev);
 111
 112         drm_vblank_offdelay = VBLANK_OFF_DELAY;
 113
 114         platform_set_drvdata(dev->platformdev, dev);
 115
 116         /* force connectors detection */
 117         drm_helper_hpd_irq_event(dev);
 118
 119         return 0;
 120
 121 err_vblank:
 122         drm_vblank_cleanup(dev);
 123 err_display_cleanup:
 124         exynos_drm_remove_displays(dev);
 125 err_manager_cleanup:
 126         exynos_drm_remove_managers(dev);
 127 err_mode_config_cleanup:
 128         drm_mode_config_cleanup(dev);
 129         drm_release_iommu_mapping(dev);
 130 err_free_private:
 131         kfree(private);
 132
 133         return ret;
 134 }
 135
 136 static int exynos_drm_unload(struct drm_device *dev)
 137 {
 138         exynos_drm_fbdev_fini(dev);
 139         exynos_drm_device_unregister(dev);
 140         drm_vblank_cleanup(dev);
 141         drm_kms_helper_poll_fini(dev);
 142         exynos_drm_remove_displays(dev);
 143         exynos_drm_remove_managers(dev);
 144         drm_mode_config_cleanup(dev);
 145
 146         drm_release_iommu_mapping(dev);
 147         kfree(dev->dev_private);
 148
 149         dev->dev_private = NULL;
 150
 151         return 0;
 152 }
 153
 154 static const struct file_operations exynos_drm_gem_fops = {
 155         .mmap = exynos_drm_gem_mmap_buffer,
 156 };
 157
 158 static int exynos_drm_suspend(struct drm_device *dev, pm_message_t state)
 159 {
 160         struct drm_connector *connector;
 161
 162         drm_modeset_lock_all(dev);
 163         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 164                 int old_dpms = connector->dpms;
 165
 166                 if (connector->funcs->dpms)
 167                         connector->funcs->dpms(connector, DRM_MODE_DPMS_OFF);
 168
 169                 /* Set the old mode back to the connector for resume */
 170                 connector->dpms = old_dpms;
 171         }
 172         drm_modeset_unlock_all(dev);
 173
 174         return 0;
 175 }
 176
 177 static int exynos_drm_resume(struct drm_device *dev)
 178 {
 179         struct drm_connector *connector;
 180
 181         drm_modeset_lock_all(dev);
 182         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 183                 if (connector->funcs->dpms)
 184                         connector->funcs->dpms(connector, connector->dpms);
 185         }
 186
 187         drm_helper_resume_force_mode(dev);
 188         drm_modeset_unlock_all(dev);
 189
 190         return 0;
 191 }
 192
 193 static int exynos_drm_open(struct drm_device *dev, struct drm_file *file)
 194 {
 195         struct drm_exynos_file_private *file_priv;
 196         struct file *anon_filp;
 197         int ret;
 198
 199         file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
 200         if (!file_priv)
 201                 return -ENOMEM;
 202
 203         file->driver_priv = file_priv;
 204
 205         ret = exynos_drm_subdrv_open(dev, file);
 206         if (ret)
 207                 goto err_file_priv_free;
 208
 209         anon_filp = anon_inode_getfile("exynos_gem", &exynos_drm_gem_fops,
 210                                         NULL, 0);
 211         if (IS_ERR(anon_filp)) {
 212                 ret = PTR_ERR(anon_filp);
 213                 goto err_subdrv_close;
 214         }
 215
 216         anon_filp->f_mode = FMODE_READ | FMODE_WRITE;
 217         file_priv->anon_filp = anon_filp;
 218
 219         return ret;
 220
 221 err_subdrv_close:
 222         exynos_drm_subdrv_close(dev, file);
 223
 224 err_file_priv_free:
 225         kfree(file_priv);
 226         file->driver_priv = NULL;
 227         return ret;
 228 }
 229
 230 static void exynos_drm_preclose(struct drm_device *dev,
 231                                         struct drm_file *file)
 232 {
 233         exynos_drm_subdrv_close(dev, file);
 234 }
 235
 236 static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
 237 {
 238         struct exynos_drm_private *private = dev->dev_private;
 239         struct drm_exynos_file_private *file_priv;
 240         struct drm_pending_vblank_event *v, *vt;
 241         struct drm_pending_event *e, *et;
 242         unsigned long flags;
 243
 244         if (!file->driver_priv)
 245                 return;
 246
 247         /* Release all events not unhandled by page flip handler. */
 248         spin_lock_irqsave(&dev->event_lock, flags);
 249         list_for_each_entry_safe(v, vt, &private->pageflip_event_list,
 250                         base.link) {
 251                 if (v->base.file_priv == file) {
 252                         list_del(&v->base.link);
 253                         drm_vblank_put(dev, v->pipe);
 254                         v->base.destroy(&v->base);
 255                 }
 256         }
 257
 258         /* Release all events handled by page flip handler but not freed. */
 259         list_for_each_entry_safe(e, et, &file->event_list, link) {
 260                 list_del(&e->link);
 261                 e->destroy(e);
 262         }
 263         spin_unlock_irqrestore(&dev->event_lock, flags);
 264
 265         file_priv = file->driver_priv;
 266         if (file_priv->anon_filp)
 267                 fput(file_priv->anon_filp);
 268
 269         kfree(file->driver_priv);
 270         file->driver_priv = NULL;
 271 }
 272
 273 static void exynos_drm_lastclose(struct drm_device *dev)
 274 {
 275         exynos_drm_fbdev_restore_mode(dev);
 276 }
 277
 278 static const struct vm_operations_struct exynos_drm_gem_vm_ops = {
 279         .fault = exynos_drm_gem_fault,
 280         .open = drm_gem_vm_open,
 281         .close = drm_gem_vm_close,
 282 };
 283
 284 static const struct drm_ioctl_desc exynos_ioctls[] = {
 285         DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl,
 286                         DRM_UNLOCKED | DRM_AUTH),
 287         DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MAP_OFFSET,
 288                         exynos_drm_gem_map_offset_ioctl, DRM_UNLOCKED |
 289                         DRM_AUTH),
 290         DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MMAP,
 291                         exynos_drm_gem_mmap_ioctl, DRM_UNLOCKED | DRM_AUTH),
 292         DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET,
 293                         exynos_drm_gem_get_ioctl, DRM_UNLOCKED),
 294         DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION,
 295                         vidi_connection_ioctl, DRM_UNLOCKED | DRM_AUTH),
 296         DRM_IOCTL_DEF_DRV(EXYNOS_G2D_GET_VER,
 297                         exynos_g2d_get_ver_ioctl, DRM_UNLOCKED | DRM_AUTH),
 298         DRM_IOCTL_DEF_DRV(EXYNOS_G2D_SET_CMDLIST,
 299                         exynos_g2d_set_cmdlist_ioctl, DRM_UNLOCKED | DRM_AUTH),
 300         DRM_IOCTL_DEF_DRV(EXYNOS_G2D_EXEC,
 301                         exynos_g2d_exec_ioctl, DRM_UNLOCKED | DRM_AUTH),
 302         DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_PROPERTY,
 303                         exynos_drm_ipp_get_property, DRM_UNLOCKED | DRM_AUTH),
 304         DRM_IOCTL_DEF_DRV(EXYNOS_IPP_SET_PROPERTY,
 305                         exynos_drm_ipp_set_property, DRM_UNLOCKED | DRM_AUTH),
 306         DRM_IOCTL_DEF_DRV(EXYNOS_IPP_QUEUE_BUF,
 307                         exynos_drm_ipp_queue_buf, DRM_UNLOCKED | DRM_AUTH),
 308         DRM_IOCTL_DEF_DRV(EXYNOS_IPP_CMD_CTRL,
 309                         exynos_drm_ipp_cmd_ctrl, DRM_UNLOCKED | DRM_AUTH),
 310 };
 311
 312 static const struct file_operations exynos_drm_driver_fops = {
 313         .owner          = THIS_MODULE,
 314         .open           = drm_open,
 315         .mmap           = exynos_drm_gem_mmap,
 316         .poll           = drm_poll,
 317         .read           = drm_read,
 318         .unlocked_ioctl = drm_ioctl,
 319 #ifdef CONFIG_COMPAT
 320         .compat_ioctl = drm_compat_ioctl,
 321 #endif
 322         .release        = drm_release,
 323 };
 324
 325 static struct drm_driver exynos_drm_driver = {
 326         .driver_features        = DRIVER_HAVE_IRQ | DRIVER_MODESET |
 327                                         DRIVER_GEM | DRIVER_PRIME,
 328         .load                   = exynos_drm_load,
 329         .unload                 = exynos_drm_unload,
 330         .suspend                = exynos_drm_suspend,
 331         .resume                 = exynos_drm_resume,
 332         .open                   = exynos_drm_open,
 333         .preclose               = exynos_drm_preclose,
 334         .lastclose              = exynos_drm_lastclose,
 335         .postclose              = exynos_drm_postclose,
 336         .get_vblank_counter     = drm_vblank_count,
 337         .enable_vblank          = exynos_drm_crtc_enable_vblank,
 338         .disable_vblank         = exynos_drm_crtc_disable_vblank,
 339         .gem_free_object        = exynos_drm_gem_free_object,
 340         .gem_vm_ops             = &exynos_drm_gem_vm_ops,
 341         .dumb_create            = exynos_drm_gem_dumb_create,
 342         .dumb_map_offset        = exynos_drm_gem_dumb_map_offset,
 343         .dumb_destroy           = drm_gem_dumb_destroy,
 344         .prime_handle_to_fd     = drm_gem_prime_handle_to_fd,
 345         .prime_fd_to_handle     = drm_gem_prime_fd_to_handle,
 346         .gem_prime_export       = exynos_dmabuf_prime_export,
 347         .gem_prime_import       = exynos_dmabuf_prime_import,
 348         .ioctls                 = exynos_ioctls,
 349         .num_ioctls             = ARRAY_SIZE(exynos_ioctls),
 350         .fops                   = &exynos_drm_driver_fops,
 351         .name   = DRIVER_NAME,
 352         .desc   = DRIVER_DESC,
 353         .date   = DRIVER_DATE,
 354         .major  = DRIVER_MAJOR,
 355         .minor  = DRIVER_MINOR,
 356 };
 357
 358 static int exynos_drm_platform_probe(struct platform_device *pdev)
 359 {
 360         int ret;
 361
 362         ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
 363         if (ret)
 364                 return ret;
 365
 366         pm_runtime_enable(&pdev->dev);
 367         pm_runtime_get_sync(&pdev->dev);
 368
 369         return drm_platform_init(&exynos_drm_driver, pdev);
 370 }
 371
 372 static int exynos_drm_platform_remove(struct platform_device *pdev)
 373 {
 374         drm_put_dev(platform_get_drvdata(pdev));
 375
 376         return 0;
 377 }
 378
 379 #ifdef CONFIG_PM_SLEEP
 380 static int exynos_drm_sys_suspend(struct device *dev)
 381 {
 382         struct drm_device *drm_dev = dev_get_drvdata(dev);
 383         pm_message_t message;
 384
 385         if (pm_runtime_suspended(dev))
 386                 return 0;
 387
 388         message.event = PM_EVENT_SUSPEND;
 389         return exynos_drm_suspend(drm_dev, message);
 390 }
 391
 392 static int exynos_drm_sys_resume(struct device *dev)
 393 {
 394         struct drm_device *drm_dev = dev_get_drvdata(dev);
 395
 396         if (pm_runtime_suspended(dev))
 397                 return 0;
 398
 399         return exynos_drm_resume(drm_dev);
 400 }
 401 #endif
 402
 403 #ifdef CONFIG_PM_RUNTIME
 404 static int exynos_drm_runtime_suspend(struct device *dev)
 405 {
 406         struct drm_device *drm_dev = dev_get_drvdata(dev);
 407         pm_message_t message;
 408
 409         if (pm_runtime_suspended(dev))
 410                 return 0;
 411
 412         message.event = PM_EVENT_SUSPEND;
 413         return exynos_drm_suspend(drm_dev, message);
 414 }
 415
 416 static int exynos_drm_runtime_resume(struct device *dev)
 417 {
 418         struct drm_device *drm_dev = dev_get_drvdata(dev);
 419
 420         if (!pm_runtime_suspended(dev))
 421                 return 0;
 422
 423         return exynos_drm_resume(drm_dev);
 424 }
 425 #endif
 426
 427 static const struct dev_pm_ops exynos_drm_pm_ops = {
 428         SET_SYSTEM_SLEEP_PM_OPS(exynos_drm_sys_suspend, exynos_drm_sys_resume)
 429         SET_RUNTIME_PM_OPS(exynos_drm_runtime_suspend,
 430                         exynos_drm_runtime_resume, NULL)
 431 };
 432
 433 static struct platform_driver exynos_drm_platform_driver = {
 434         .probe          = exynos_drm_platform_probe,
 435         .remove         = exynos_drm_platform_remove,
 436         .driver         = {
 437                 .owner  = THIS_MODULE,
 438                 .name   = "exynos-drm",
 439                 .pm     = &exynos_drm_pm_ops,
 440         },
 441 };
 442
 443 static int __init exynos_drm_init(void)
 444 {
 445         int ret;
 446
 447 #ifdef CONFIG_DRM_EXYNOS_DP
 448         ret = platform_driver_register(&dp_driver);
 449         if (ret < 0)
 450                 goto out_dp;
 451 #endif
 452
 453 #ifdef CONFIG_DRM_EXYNOS_FIMD
 454         ret = platform_driver_register(&fimd_driver);
 455         if (ret < 0)
 456                 goto out_fimd;
 457 #endif
 458
 459 #ifdef CONFIG_DRM_EXYNOS_HDMI
 460         ret = platform_driver_register(&hdmi_driver);
 461         if (ret < 0)
 462                 goto out_hdmi;
 463         ret = platform_driver_register(&mixer_driver);
 464         if (ret < 0)
 465                 goto out_mixer;
 466 #endif
 467
 468 #ifdef CONFIG_DRM_EXYNOS_VIDI
 469         ret = platform_driver_register(&vidi_driver);
 470         if (ret < 0)
 471                 goto out_vidi;
 472 #endif
 473
 474 #ifdef CONFIG_DRM_EXYNOS_G2D
 475         ret = platform_driver_register(&g2d_driver);
 476         if (ret < 0)
 477                 goto out_g2d;
 478 #endif
 479
 480 #ifdef CONFIG_DRM_EXYNOS_FIMC
 481         ret = platform_driver_register(&fimc_driver);
 482         if (ret < 0)
 483                 goto out_fimc;
 484 #endif
 485
 486 #ifdef CONFIG_DRM_EXYNOS_ROTATOR
 487         ret = platform_driver_register(&rotator_driver);
 488         if (ret < 0)
 489                 goto out_rotator;
 490 #endif
 491
 492 #ifdef CONFIG_DRM_EXYNOS_GSC
 493         ret = platform_driver_register(&gsc_driver);
 494         if (ret < 0)
 495                 goto out_gsc;
 496 #endif
 497
 498 #ifdef CONFIG_DRM_EXYNOS_IPP
 499         ret = platform_driver_register(&ipp_driver);
 500         if (ret < 0)
 501                 goto out_ipp;
 502
 503         ret = exynos_platform_device_ipp_register();
 504         if (ret < 0)
 505                 goto out_ipp_dev;
 506 #endif
 507
 508         ret = platform_driver_register(&exynos_drm_platform_driver);
 509         if (ret < 0)
 510                 goto out_drm;
 511
 512         exynos_drm_pdev = platform_device_register_simple("exynos-drm", -1,
 513                                 NULL, 0);
 514         if (IS_ERR(exynos_drm_pdev)) {
 515                 ret = PTR_ERR(exynos_drm_pdev);
 516                 goto out;
 517         }
 518
 519         return 0;
 520
 521 out:
 522         platform_driver_unregister(&exynos_drm_platform_driver);
 523
 524 out_drm:
 525 #ifdef CONFIG_DRM_EXYNOS_IPP
 526         exynos_platform_device_ipp_unregister();
 527 out_ipp_dev:
 528         platform_driver_unregister(&ipp_driver);
 529 out_ipp:
 530 #endif
 531
 532 #ifdef CONFIG_DRM_EXYNOS_GSC
 533         platform_driver_unregister(&gsc_driver);
 534 out_gsc:
 535 #endif
 536
 537 #ifdef CONFIG_DRM_EXYNOS_ROTATOR
 538         platform_driver_unregister(&rotator_driver);
 539 out_rotator:
 540 #endif
 541
 542 #ifdef CONFIG_DRM_EXYNOS_FIMC
 543         platform_driver_unregister(&fimc_driver);
 544 out_fimc:
 545 #endif
 546
 547 #ifdef CONFIG_DRM_EXYNOS_G2D
 548         platform_driver_unregister(&g2d_driver);
 549 out_g2d:
 550 #endif
 551
 552 #ifdef CONFIG_DRM_EXYNOS_VIDI
 553         platform_driver_unregister(&vidi_driver);
 554 out_vidi:
 555 #endif
 556
 557 #ifdef CONFIG_DRM_EXYNOS_HDMI
 558         platform_driver_unregister(&mixer_driver);
 559 out_mixer:
 560         platform_driver_unregister(&hdmi_driver);
 561 out_hdmi:
 562 #endif
 563
 564 #ifdef CONFIG_DRM_EXYNOS_FIMD
 565         platform_driver_unregister(&fimd_driver);
 566 out_fimd:
 567 #endif
 568
 569 #ifdef CONFIG_DRM_EXYNOS_DP
 570         platform_driver_unregister(&dp_driver);
 571 out_dp:
 572 #endif
 573         return ret;
 574 }
 575
 576 static void __exit exynos_drm_exit(void)
 577 {
 578         platform_device_unregister(exynos_drm_pdev);
 579
 580         platform_driver_unregister(&exynos_drm_platform_driver);
 581
 582 #ifdef CONFIG_DRM_EXYNOS_IPP
 583         exynos_platform_device_ipp_unregister();
 584         platform_driver_unregister(&ipp_driver);
 585 #endif
 586
 587 #ifdef CONFIG_DRM_EXYNOS_GSC
 588         platform_driver_unregister(&gsc_driver);
 589 #endif
 590
 591 #ifdef CONFIG_DRM_EXYNOS_ROTATOR
 592         platform_driver_unregister(&rotator_driver);
 593 #endif
 594
 595 #ifdef CONFIG_DRM_EXYNOS_FIMC
 596         platform_driver_unregister(&fimc_driver);
 597 #endif
 598
 599 #ifdef CONFIG_DRM_EXYNOS_G2D
 600         platform_driver_unregister(&g2d_driver);
 601 #endif
 602
 603 #ifdef CONFIG_DRM_EXYNOS_HDMI
 604         platform_driver_unregister(&mixer_driver);
 605         platform_driver_unregister(&hdmi_driver);
 606 #endif
 607
 608 #ifdef CONFIG_DRM_EXYNOS_VIDI
 609         platform_driver_unregister(&vidi_driver);
 610 #endif
 611
 612 #ifdef CONFIG_DRM_EXYNOS_FIMD
 613         platform_driver_unregister(&fimd_driver);
 614 #endif
 615
 616 #ifdef CONFIG_DRM_EXYNOS_DP
 617         platform_driver_unregister(&dp_driver);
 618 #endif
 619 }
 620
 621 module_init(exynos_drm_init);
 622 module_exit(exynos_drm_exit);
 623
 624 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
 625 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
 626 MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
 627 MODULE_DESCRIPTION("Samsung SoC DRM Driver");
 628 MODULE_LICENSE("GPL");