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_atomic.h> 17 #include <drm/drm_atomic_helper.h> 18 #include <drm/drm_crtc_helper.h> 19 #include <drm/drm_fb_helper.h> 20 21 #include <linux/component.h> 22 23 #include <drm/exynos_drm.h> 24 25 #include "exynos_drm_drv.h" 26 #include "exynos_drm_fbdev.h" 27 #include "exynos_drm_fb.h" 28 #include "exynos_drm_gem.h" 29 #include "exynos_drm_plane.h" 30 #include "exynos_drm_ipp.h" 31 #include "exynos_drm_vidi.h" 32 #include "exynos_drm_g2d.h" 33 #include "exynos_drm_iommu.h" 34 35 #define DRIVER_NAME "exynos" 36 #define DRIVER_DESC "Samsung SoC DRM" 37 #define DRIVER_DATE "20180330" 38 39 /* 40 * Interface history: 41 * 42 * 1.0 - Original version 43 * 1.1 - Upgrade IPP driver to version 2.0 44 */ 45 #define DRIVER_MAJOR 1 46 #define DRIVER_MINOR 1 47 48 static int exynos_drm_open(struct drm_device *dev, struct drm_file *file) 49 { 50 struct drm_exynos_file_private *file_priv; 51 int ret; 52 53 file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL); 54 if (!file_priv) 55 return -ENOMEM; 56 57 file->driver_priv = file_priv; 58 59 ret = exynos_drm_subdrv_open(dev, file); 60 if (ret) 61 goto err_file_priv_free; 62 63 return ret; 64 65 err_file_priv_free: 66 kfree(file_priv); 67 file->driver_priv = NULL; 68 return ret; 69 } 70 71 static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file) 72 { 73 exynos_drm_subdrv_close(dev, file); 74 kfree(file->driver_priv); 75 file->driver_priv = NULL; 76 } 77 78 static const struct vm_operations_struct exynos_drm_gem_vm_ops = { 79 .fault = exynos_drm_gem_fault, 80 .open = drm_gem_vm_open, 81 .close = drm_gem_vm_close, 82 }; 83 84 static const struct drm_ioctl_desc exynos_ioctls[] = { 85 DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl, 86 DRM_AUTH | DRM_RENDER_ALLOW), 87 DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MAP, exynos_drm_gem_map_ioctl, 88 DRM_AUTH | DRM_RENDER_ALLOW), 89 DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET, exynos_drm_gem_get_ioctl, 90 DRM_RENDER_ALLOW), 91 DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION, vidi_connection_ioctl, 92 DRM_AUTH), 93 DRM_IOCTL_DEF_DRV(EXYNOS_G2D_GET_VER, exynos_g2d_get_ver_ioctl, 94 DRM_AUTH | DRM_RENDER_ALLOW), 95 DRM_IOCTL_DEF_DRV(EXYNOS_G2D_SET_CMDLIST, exynos_g2d_set_cmdlist_ioctl, 96 DRM_AUTH | DRM_RENDER_ALLOW), 97 DRM_IOCTL_DEF_DRV(EXYNOS_G2D_EXEC, exynos_g2d_exec_ioctl, 98 DRM_AUTH | DRM_RENDER_ALLOW), 99 DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_RESOURCES, 100 exynos_drm_ipp_get_res_ioctl, 101 DRM_AUTH | DRM_RENDER_ALLOW), 102 DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_CAPS, exynos_drm_ipp_get_caps_ioctl, 103 DRM_AUTH | DRM_RENDER_ALLOW), 104 DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_LIMITS, 105 exynos_drm_ipp_get_limits_ioctl, 106 DRM_AUTH | DRM_RENDER_ALLOW), 107 DRM_IOCTL_DEF_DRV(EXYNOS_IPP_COMMIT, exynos_drm_ipp_commit_ioctl, 108 DRM_AUTH | DRM_RENDER_ALLOW), 109 }; 110 111 static const struct file_operations exynos_drm_driver_fops = { 112 .owner = THIS_MODULE, 113 .open = drm_open, 114 .mmap = exynos_drm_gem_mmap, 115 .poll = drm_poll, 116 .read = drm_read, 117 .unlocked_ioctl = drm_ioctl, 118 .compat_ioctl = drm_compat_ioctl, 119 .release = drm_release, 120 }; 121 122 static struct drm_driver exynos_drm_driver = { 123 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME 124 | DRIVER_ATOMIC | DRIVER_RENDER, 125 .open = exynos_drm_open, 126 .lastclose = drm_fb_helper_lastclose, 127 .postclose = exynos_drm_postclose, 128 .gem_free_object_unlocked = exynos_drm_gem_free_object, 129 .gem_vm_ops = &exynos_drm_gem_vm_ops, 130 .dumb_create = exynos_drm_gem_dumb_create, 131 .prime_handle_to_fd = drm_gem_prime_handle_to_fd, 132 .prime_fd_to_handle = drm_gem_prime_fd_to_handle, 133 .gem_prime_export = drm_gem_prime_export, 134 .gem_prime_import = exynos_drm_gem_prime_import, 135 .gem_prime_get_sg_table = exynos_drm_gem_prime_get_sg_table, 136 .gem_prime_import_sg_table = exynos_drm_gem_prime_import_sg_table, 137 .gem_prime_vmap = exynos_drm_gem_prime_vmap, 138 .gem_prime_vunmap = exynos_drm_gem_prime_vunmap, 139 .gem_prime_mmap = exynos_drm_gem_prime_mmap, 140 .ioctls = exynos_ioctls, 141 .num_ioctls = ARRAY_SIZE(exynos_ioctls), 142 .fops = &exynos_drm_driver_fops, 143 .name = DRIVER_NAME, 144 .desc = DRIVER_DESC, 145 .date = DRIVER_DATE, 146 .major = DRIVER_MAJOR, 147 .minor = DRIVER_MINOR, 148 }; 149 150 #ifdef CONFIG_PM_SLEEP 151 static int exynos_drm_suspend(struct device *dev) 152 { 153 struct drm_device *drm_dev = dev_get_drvdata(dev); 154 struct exynos_drm_private *private; 155 156 if (pm_runtime_suspended(dev) || !drm_dev) 157 return 0; 158 159 private = drm_dev->dev_private; 160 161 drm_kms_helper_poll_disable(drm_dev); 162 exynos_drm_fbdev_suspend(drm_dev); 163 private->suspend_state = drm_atomic_helper_suspend(drm_dev); 164 if (IS_ERR(private->suspend_state)) { 165 exynos_drm_fbdev_resume(drm_dev); 166 drm_kms_helper_poll_enable(drm_dev); 167 return PTR_ERR(private->suspend_state); 168 } 169 170 return 0; 171 } 172 173 static int exynos_drm_resume(struct device *dev) 174 { 175 struct drm_device *drm_dev = dev_get_drvdata(dev); 176 struct exynos_drm_private *private; 177 178 if (pm_runtime_suspended(dev) || !drm_dev) 179 return 0; 180 181 private = drm_dev->dev_private; 182 drm_atomic_helper_resume(drm_dev, private->suspend_state); 183 exynos_drm_fbdev_resume(drm_dev); 184 drm_kms_helper_poll_enable(drm_dev); 185 186 return 0; 187 } 188 #endif 189 190 static const struct dev_pm_ops exynos_drm_pm_ops = { 191 SET_SYSTEM_SLEEP_PM_OPS(exynos_drm_suspend, exynos_drm_resume) 192 }; 193 194 /* forward declaration */ 195 static struct platform_driver exynos_drm_platform_driver; 196 197 struct exynos_drm_driver_info { 198 struct platform_driver *driver; 199 unsigned int flags; 200 }; 201 202 #define DRM_COMPONENT_DRIVER BIT(0) /* supports component framework */ 203 #define DRM_VIRTUAL_DEVICE BIT(1) /* create virtual platform device */ 204 #define DRM_DMA_DEVICE BIT(2) /* can be used for dma allocations */ 205 #define DRM_FIMC_DEVICE BIT(3) /* devices shared with V4L2 subsystem */ 206 207 #define DRV_PTR(drv, cond) (IS_ENABLED(cond) ? &drv : NULL) 208 209 /* 210 * Connector drivers should not be placed before associated crtc drivers, 211 * because connector requires pipe number of its crtc during initialization. 212 */ 213 static struct exynos_drm_driver_info exynos_drm_drivers[] = { 214 { 215 DRV_PTR(fimd_driver, CONFIG_DRM_EXYNOS_FIMD), 216 DRM_COMPONENT_DRIVER | DRM_DMA_DEVICE 217 }, { 218 DRV_PTR(exynos5433_decon_driver, CONFIG_DRM_EXYNOS5433_DECON), 219 DRM_COMPONENT_DRIVER | DRM_DMA_DEVICE 220 }, { 221 DRV_PTR(decon_driver, CONFIG_DRM_EXYNOS7_DECON), 222 DRM_COMPONENT_DRIVER | DRM_DMA_DEVICE 223 }, { 224 DRV_PTR(mixer_driver, CONFIG_DRM_EXYNOS_MIXER), 225 DRM_COMPONENT_DRIVER | DRM_DMA_DEVICE 226 }, { 227 DRV_PTR(mic_driver, CONFIG_DRM_EXYNOS_MIC), 228 DRM_COMPONENT_DRIVER 229 }, { 230 DRV_PTR(dp_driver, CONFIG_DRM_EXYNOS_DP), 231 DRM_COMPONENT_DRIVER 232 }, { 233 DRV_PTR(dsi_driver, CONFIG_DRM_EXYNOS_DSI), 234 DRM_COMPONENT_DRIVER 235 }, { 236 DRV_PTR(hdmi_driver, CONFIG_DRM_EXYNOS_HDMI), 237 DRM_COMPONENT_DRIVER 238 }, { 239 DRV_PTR(vidi_driver, CONFIG_DRM_EXYNOS_VIDI), 240 DRM_COMPONENT_DRIVER | DRM_VIRTUAL_DEVICE 241 }, { 242 DRV_PTR(g2d_driver, CONFIG_DRM_EXYNOS_G2D), 243 }, { 244 DRV_PTR(fimc_driver, CONFIG_DRM_EXYNOS_FIMC), 245 DRM_COMPONENT_DRIVER | DRM_FIMC_DEVICE, 246 }, { 247 DRV_PTR(rotator_driver, CONFIG_DRM_EXYNOS_ROTATOR), 248 DRM_COMPONENT_DRIVER 249 }, { 250 DRV_PTR(scaler_driver, CONFIG_DRM_EXYNOS_SCALER), 251 DRM_COMPONENT_DRIVER 252 }, { 253 DRV_PTR(gsc_driver, CONFIG_DRM_EXYNOS_GSC), 254 DRM_COMPONENT_DRIVER 255 }, { 256 &exynos_drm_platform_driver, 257 DRM_VIRTUAL_DEVICE 258 } 259 }; 260 261 static int compare_dev(struct device *dev, void *data) 262 { 263 return dev == (struct device *)data; 264 } 265 266 static struct component_match *exynos_drm_match_add(struct device *dev) 267 { 268 struct component_match *match = NULL; 269 int i; 270 271 for (i = 0; i < ARRAY_SIZE(exynos_drm_drivers); ++i) { 272 struct exynos_drm_driver_info *info = &exynos_drm_drivers[i]; 273 struct device *p = NULL, *d; 274 275 if (!info->driver || !(info->flags & DRM_COMPONENT_DRIVER)) 276 continue; 277 278 while ((d = bus_find_device(&platform_bus_type, p, 279 &info->driver->driver, 280 (void *)platform_bus_type.match))) { 281 put_device(p); 282 283 if (!(info->flags & DRM_FIMC_DEVICE) || 284 exynos_drm_check_fimc_device(d) == 0) 285 component_match_add(dev, &match, 286 compare_dev, d); 287 p = d; 288 } 289 put_device(p); 290 } 291 292 return match ?: ERR_PTR(-ENODEV); 293 } 294 295 static struct device *exynos_drm_get_dma_device(void) 296 { 297 int i; 298 299 for (i = 0; i < ARRAY_SIZE(exynos_drm_drivers); ++i) { 300 struct exynos_drm_driver_info *info = &exynos_drm_drivers[i]; 301 struct device *dev; 302 303 if (!info->driver || !(info->flags & DRM_DMA_DEVICE)) 304 continue; 305 306 while ((dev = bus_find_device(&platform_bus_type, NULL, 307 &info->driver->driver, 308 (void *)platform_bus_type.match))) { 309 put_device(dev); 310 return dev; 311 } 312 } 313 return NULL; 314 } 315 316 static int exynos_drm_bind(struct device *dev) 317 { 318 struct exynos_drm_private *private; 319 struct drm_encoder *encoder; 320 struct drm_device *drm; 321 unsigned int clone_mask; 322 int cnt, ret; 323 324 drm = drm_dev_alloc(&exynos_drm_driver, dev); 325 if (IS_ERR(drm)) 326 return PTR_ERR(drm); 327 328 private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL); 329 if (!private) { 330 ret = -ENOMEM; 331 goto err_free_drm; 332 } 333 334 init_waitqueue_head(&private->wait); 335 spin_lock_init(&private->lock); 336 337 dev_set_drvdata(dev, drm); 338 drm->dev_private = (void *)private; 339 340 /* the first real CRTC device is used for all dma mapping operations */ 341 private->dma_dev = exynos_drm_get_dma_device(); 342 if (!private->dma_dev) { 343 DRM_ERROR("no device found for DMA mapping operations.\n"); 344 ret = -ENODEV; 345 goto err_free_private; 346 } 347 DRM_INFO("Exynos DRM: using %s device for DMA mapping operations\n", 348 dev_name(private->dma_dev)); 349 350 /* create common IOMMU mapping for all devices attached to Exynos DRM */ 351 ret = drm_create_iommu_mapping(drm); 352 if (ret < 0) { 353 DRM_ERROR("failed to create iommu mapping.\n"); 354 goto err_free_private; 355 } 356 357 drm_mode_config_init(drm); 358 359 exynos_drm_mode_config_init(drm); 360 361 /* setup possible_clones. */ 362 cnt = 0; 363 clone_mask = 0; 364 list_for_each_entry(encoder, &drm->mode_config.encoder_list, head) 365 clone_mask |= (1 << (cnt++)); 366 367 list_for_each_entry(encoder, &drm->mode_config.encoder_list, head) 368 encoder->possible_clones = clone_mask; 369 370 /* Try to bind all sub drivers. */ 371 ret = component_bind_all(drm->dev, drm); 372 if (ret) 373 goto err_mode_config_cleanup; 374 375 ret = drm_vblank_init(drm, drm->mode_config.num_crtc); 376 if (ret) 377 goto err_unbind_all; 378 379 /* Probe non kms sub drivers and virtual display driver. */ 380 ret = exynos_drm_device_subdrv_probe(drm); 381 if (ret) 382 goto err_unbind_all; 383 384 drm_mode_config_reset(drm); 385 386 /* 387 * enable drm irq mode. 388 * - with irq_enabled = true, we can use the vblank feature. 389 * 390 * P.S. note that we wouldn't use drm irq handler but 391 * just specific driver own one instead because 392 * drm framework supports only one irq handler. 393 */ 394 drm->irq_enabled = true; 395 396 /* init kms poll for handling hpd */ 397 drm_kms_helper_poll_init(drm); 398 399 ret = exynos_drm_fbdev_init(drm); 400 if (ret) 401 goto err_cleanup_poll; 402 403 /* register the DRM device */ 404 ret = drm_dev_register(drm, 0); 405 if (ret < 0) 406 goto err_cleanup_fbdev; 407 408 return 0; 409 410 err_cleanup_fbdev: 411 exynos_drm_fbdev_fini(drm); 412 err_cleanup_poll: 413 drm_kms_helper_poll_fini(drm); 414 exynos_drm_device_subdrv_remove(drm); 415 err_unbind_all: 416 component_unbind_all(drm->dev, drm); 417 err_mode_config_cleanup: 418 drm_mode_config_cleanup(drm); 419 drm_release_iommu_mapping(drm); 420 err_free_private: 421 kfree(private); 422 err_free_drm: 423 drm_dev_unref(drm); 424 425 return ret; 426 } 427 428 static void exynos_drm_unbind(struct device *dev) 429 { 430 struct drm_device *drm = dev_get_drvdata(dev); 431 432 drm_dev_unregister(drm); 433 434 exynos_drm_device_subdrv_remove(drm); 435 436 exynos_drm_fbdev_fini(drm); 437 drm_kms_helper_poll_fini(drm); 438 439 component_unbind_all(drm->dev, drm); 440 drm_mode_config_cleanup(drm); 441 drm_release_iommu_mapping(drm); 442 443 kfree(drm->dev_private); 444 drm->dev_private = NULL; 445 dev_set_drvdata(dev, NULL); 446 447 drm_dev_unref(drm); 448 } 449 450 static const struct component_master_ops exynos_drm_ops = { 451 .bind = exynos_drm_bind, 452 .unbind = exynos_drm_unbind, 453 }; 454 455 static int exynos_drm_platform_probe(struct platform_device *pdev) 456 { 457 struct component_match *match; 458 459 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 460 461 match = exynos_drm_match_add(&pdev->dev); 462 if (IS_ERR(match)) 463 return PTR_ERR(match); 464 465 return component_master_add_with_match(&pdev->dev, &exynos_drm_ops, 466 match); 467 } 468 469 static int exynos_drm_platform_remove(struct platform_device *pdev) 470 { 471 component_master_del(&pdev->dev, &exynos_drm_ops); 472 return 0; 473 } 474 475 static struct platform_driver exynos_drm_platform_driver = { 476 .probe = exynos_drm_platform_probe, 477 .remove = exynos_drm_platform_remove, 478 .driver = { 479 .name = "exynos-drm", 480 .pm = &exynos_drm_pm_ops, 481 }, 482 }; 483 484 static void exynos_drm_unregister_devices(void) 485 { 486 int i; 487 488 for (i = ARRAY_SIZE(exynos_drm_drivers) - 1; i >= 0; --i) { 489 struct exynos_drm_driver_info *info = &exynos_drm_drivers[i]; 490 struct device *dev; 491 492 if (!info->driver || !(info->flags & DRM_VIRTUAL_DEVICE)) 493 continue; 494 495 while ((dev = bus_find_device(&platform_bus_type, NULL, 496 &info->driver->driver, 497 (void *)platform_bus_type.match))) { 498 put_device(dev); 499 platform_device_unregister(to_platform_device(dev)); 500 } 501 } 502 } 503 504 static int exynos_drm_register_devices(void) 505 { 506 struct platform_device *pdev; 507 int i; 508 509 for (i = 0; i < ARRAY_SIZE(exynos_drm_drivers); ++i) { 510 struct exynos_drm_driver_info *info = &exynos_drm_drivers[i]; 511 512 if (!info->driver || !(info->flags & DRM_VIRTUAL_DEVICE)) 513 continue; 514 515 pdev = platform_device_register_simple( 516 info->driver->driver.name, -1, NULL, 0); 517 if (IS_ERR(pdev)) 518 goto fail; 519 } 520 521 return 0; 522 fail: 523 exynos_drm_unregister_devices(); 524 return PTR_ERR(pdev); 525 } 526 527 static void exynos_drm_unregister_drivers(void) 528 { 529 int i; 530 531 for (i = ARRAY_SIZE(exynos_drm_drivers) - 1; i >= 0; --i) { 532 struct exynos_drm_driver_info *info = &exynos_drm_drivers[i]; 533 534 if (!info->driver) 535 continue; 536 537 platform_driver_unregister(info->driver); 538 } 539 } 540 541 static int exynos_drm_register_drivers(void) 542 { 543 int i, ret; 544 545 for (i = 0; i < ARRAY_SIZE(exynos_drm_drivers); ++i) { 546 struct exynos_drm_driver_info *info = &exynos_drm_drivers[i]; 547 548 if (!info->driver) 549 continue; 550 551 ret = platform_driver_register(info->driver); 552 if (ret) 553 goto fail; 554 } 555 return 0; 556 fail: 557 exynos_drm_unregister_drivers(); 558 return ret; 559 } 560 561 static int exynos_drm_init(void) 562 { 563 int ret; 564 565 ret = exynos_drm_register_devices(); 566 if (ret) 567 return ret; 568 569 ret = exynos_drm_register_drivers(); 570 if (ret) 571 goto err_unregister_pdevs; 572 573 return 0; 574 575 err_unregister_pdevs: 576 exynos_drm_unregister_devices(); 577 578 return ret; 579 } 580 581 static void exynos_drm_exit(void) 582 { 583 exynos_drm_unregister_drivers(); 584 exynos_drm_unregister_devices(); 585 } 586 587 module_init(exynos_drm_init); 588 module_exit(exynos_drm_exit); 589 590 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>"); 591 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>"); 592 MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>"); 593 MODULE_DESCRIPTION("Samsung SoC DRM Driver"); 594 MODULE_LICENSE("GPL"); 595