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 <drm/drmP.h> 15 #include <drm/drm_crtc_helper.h> 16 17 #include <drm/exynos_drm.h> 18 19 #include "exynos_drm_drv.h" 20 #include "exynos_drm_crtc.h" 21 #include "exynos_drm_encoder.h" 22 #include "exynos_drm_fbdev.h" 23 #include "exynos_drm_fb.h" 24 #include "exynos_drm_gem.h" 25 #include "exynos_drm_plane.h" 26 #include "exynos_drm_vidi.h" 27 #include "exynos_drm_dmabuf.h" 28 #include "exynos_drm_g2d.h" 29 #include "exynos_drm_ipp.h" 30 #include "exynos_drm_iommu.h" 31 32 #define DRIVER_NAME "exynos" 33 #define DRIVER_DESC "Samsung SoC DRM" 34 #define DRIVER_DATE "20110530" 35 #define DRIVER_MAJOR 1 36 #define DRIVER_MINOR 0 37 38 #define VBLANK_OFF_DELAY 50000 39 40 /* platform device pointer for eynos drm device. */ 41 static struct platform_device *exynos_drm_pdev; 42 43 static int exynos_drm_load(struct drm_device *dev, unsigned long flags) 44 { 45 struct exynos_drm_private *private; 46 int ret; 47 int nr; 48 49 private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL); 50 if (!private) 51 return -ENOMEM; 52 53 INIT_LIST_HEAD(&private->pageflip_event_list); 54 dev->dev_private = (void *)private; 55 56 /* 57 * create mapping to manage iommu table and set a pointer to iommu 58 * mapping structure to iommu_mapping of private data. 59 * also this iommu_mapping can be used to check if iommu is supported 60 * or not. 61 */ 62 ret = drm_create_iommu_mapping(dev); 63 if (ret < 0) { 64 DRM_ERROR("failed to create iommu mapping.\n"); 65 goto err_crtc; 66 } 67 68 drm_mode_config_init(dev); 69 70 /* init kms poll for handling hpd */ 71 drm_kms_helper_poll_init(dev); 72 73 exynos_drm_mode_config_init(dev); 74 75 /* 76 * EXYNOS4 is enough to have two CRTCs and each crtc would be used 77 * without dependency of hardware. 78 */ 79 for (nr = 0; nr < MAX_CRTC; nr++) { 80 ret = exynos_drm_crtc_create(dev, nr); 81 if (ret) 82 goto err_release_iommu_mapping; 83 } 84 85 for (nr = 0; nr < MAX_PLANE; nr++) { 86 struct drm_plane *plane; 87 unsigned int possible_crtcs = (1 << MAX_CRTC) - 1; 88 89 plane = exynos_plane_init(dev, possible_crtcs, false); 90 if (!plane) 91 goto err_release_iommu_mapping; 92 } 93 94 ret = drm_vblank_init(dev, MAX_CRTC); 95 if (ret) 96 goto err_release_iommu_mapping; 97 98 /* 99 * probe sub drivers such as display controller and hdmi driver, 100 * that were registered at probe() of platform driver 101 * to the sub driver and create encoder and connector for them. 102 */ 103 ret = exynos_drm_device_register(dev); 104 if (ret) 105 goto err_vblank; 106 107 /* setup possible_clones. */ 108 exynos_drm_encoder_setup(dev); 109 110 /* 111 * create and configure fb helper and also exynos specific 112 * fbdev object. 113 */ 114 ret = exynos_drm_fbdev_init(dev); 115 if (ret) { 116 DRM_ERROR("failed to initialize drm fbdev\n"); 117 goto err_drm_device; 118 } 119 120 drm_vblank_offdelay = VBLANK_OFF_DELAY; 121 122 return 0; 123 124 err_drm_device: 125 exynos_drm_device_unregister(dev); 126 err_vblank: 127 drm_vblank_cleanup(dev); 128 err_release_iommu_mapping: 129 drm_release_iommu_mapping(dev); 130 err_crtc: 131 drm_mode_config_cleanup(dev); 132 kfree(private); 133 134 return ret; 135 } 136 137 static int exynos_drm_unload(struct drm_device *dev) 138 { 139 exynos_drm_fbdev_fini(dev); 140 exynos_drm_device_unregister(dev); 141 drm_vblank_cleanup(dev); 142 drm_kms_helper_poll_fini(dev); 143 drm_mode_config_cleanup(dev); 144 145 drm_release_iommu_mapping(dev); 146 kfree(dev->dev_private); 147 148 dev->dev_private = NULL; 149 150 return 0; 151 } 152 153 static int exynos_drm_open(struct drm_device *dev, struct drm_file *file) 154 { 155 struct drm_exynos_file_private *file_priv; 156 int ret; 157 158 file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL); 159 if (!file_priv) 160 return -ENOMEM; 161 162 file->driver_priv = file_priv; 163 164 ret = exynos_drm_subdrv_open(dev, file); 165 if (ret) { 166 kfree(file_priv); 167 file->driver_priv = NULL; 168 } 169 170 return ret; 171 } 172 173 static void exynos_drm_preclose(struct drm_device *dev, 174 struct drm_file *file) 175 { 176 struct exynos_drm_private *private = dev->dev_private; 177 struct drm_pending_vblank_event *e, *t; 178 unsigned long flags; 179 180 /* release events of current file */ 181 spin_lock_irqsave(&dev->event_lock, flags); 182 list_for_each_entry_safe(e, t, &private->pageflip_event_list, 183 base.link) { 184 if (e->base.file_priv == file) { 185 list_del(&e->base.link); 186 e->base.destroy(&e->base); 187 } 188 } 189 spin_unlock_irqrestore(&dev->event_lock, flags); 190 191 exynos_drm_subdrv_close(dev, file); 192 } 193 194 static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file) 195 { 196 if (!file->driver_priv) 197 return; 198 199 kfree(file->driver_priv); 200 file->driver_priv = NULL; 201 } 202 203 static void exynos_drm_lastclose(struct drm_device *dev) 204 { 205 exynos_drm_fbdev_restore_mode(dev); 206 } 207 208 static const struct vm_operations_struct exynos_drm_gem_vm_ops = { 209 .fault = exynos_drm_gem_fault, 210 .open = drm_gem_vm_open, 211 .close = drm_gem_vm_close, 212 }; 213 214 static const struct drm_ioctl_desc exynos_ioctls[] = { 215 DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl, 216 DRM_UNLOCKED | DRM_AUTH), 217 DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MAP_OFFSET, 218 exynos_drm_gem_map_offset_ioctl, DRM_UNLOCKED | 219 DRM_AUTH), 220 DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MMAP, 221 exynos_drm_gem_mmap_ioctl, DRM_UNLOCKED | DRM_AUTH), 222 DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET, 223 exynos_drm_gem_get_ioctl, DRM_UNLOCKED), 224 DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION, 225 vidi_connection_ioctl, DRM_UNLOCKED | DRM_AUTH), 226 DRM_IOCTL_DEF_DRV(EXYNOS_G2D_GET_VER, 227 exynos_g2d_get_ver_ioctl, DRM_UNLOCKED | DRM_AUTH), 228 DRM_IOCTL_DEF_DRV(EXYNOS_G2D_SET_CMDLIST, 229 exynos_g2d_set_cmdlist_ioctl, DRM_UNLOCKED | DRM_AUTH), 230 DRM_IOCTL_DEF_DRV(EXYNOS_G2D_EXEC, 231 exynos_g2d_exec_ioctl, DRM_UNLOCKED | DRM_AUTH), 232 DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_PROPERTY, 233 exynos_drm_ipp_get_property, DRM_UNLOCKED | DRM_AUTH), 234 DRM_IOCTL_DEF_DRV(EXYNOS_IPP_SET_PROPERTY, 235 exynos_drm_ipp_set_property, DRM_UNLOCKED | DRM_AUTH), 236 DRM_IOCTL_DEF_DRV(EXYNOS_IPP_QUEUE_BUF, 237 exynos_drm_ipp_queue_buf, DRM_UNLOCKED | DRM_AUTH), 238 DRM_IOCTL_DEF_DRV(EXYNOS_IPP_CMD_CTRL, 239 exynos_drm_ipp_cmd_ctrl, DRM_UNLOCKED | DRM_AUTH), 240 }; 241 242 static const struct file_operations exynos_drm_driver_fops = { 243 .owner = THIS_MODULE, 244 .open = drm_open, 245 .mmap = exynos_drm_gem_mmap, 246 .poll = drm_poll, 247 .read = drm_read, 248 .unlocked_ioctl = drm_ioctl, 249 #ifdef CONFIG_COMPAT 250 .compat_ioctl = drm_compat_ioctl, 251 #endif 252 .release = drm_release, 253 }; 254 255 static struct drm_driver exynos_drm_driver = { 256 .driver_features = DRIVER_HAVE_IRQ | DRIVER_MODESET | 257 DRIVER_GEM | DRIVER_PRIME, 258 .load = exynos_drm_load, 259 .unload = exynos_drm_unload, 260 .open = exynos_drm_open, 261 .preclose = exynos_drm_preclose, 262 .lastclose = exynos_drm_lastclose, 263 .postclose = exynos_drm_postclose, 264 .get_vblank_counter = drm_vblank_count, 265 .enable_vblank = exynos_drm_crtc_enable_vblank, 266 .disable_vblank = exynos_drm_crtc_disable_vblank, 267 .gem_free_object = exynos_drm_gem_free_object, 268 .gem_vm_ops = &exynos_drm_gem_vm_ops, 269 .dumb_create = exynos_drm_gem_dumb_create, 270 .dumb_map_offset = exynos_drm_gem_dumb_map_offset, 271 .dumb_destroy = drm_gem_dumb_destroy, 272 .prime_handle_to_fd = drm_gem_prime_handle_to_fd, 273 .prime_fd_to_handle = drm_gem_prime_fd_to_handle, 274 .gem_prime_export = exynos_dmabuf_prime_export, 275 .gem_prime_import = exynos_dmabuf_prime_import, 276 .ioctls = exynos_ioctls, 277 .num_ioctls = ARRAY_SIZE(exynos_ioctls), 278 .fops = &exynos_drm_driver_fops, 279 .name = DRIVER_NAME, 280 .desc = DRIVER_DESC, 281 .date = DRIVER_DATE, 282 .major = DRIVER_MAJOR, 283 .minor = DRIVER_MINOR, 284 }; 285 286 static int exynos_drm_platform_probe(struct platform_device *pdev) 287 { 288 int ret; 289 290 ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); 291 if (ret) 292 return ret; 293 294 return drm_platform_init(&exynos_drm_driver, pdev); 295 } 296 297 static int exynos_drm_platform_remove(struct platform_device *pdev) 298 { 299 drm_platform_exit(&exynos_drm_driver, pdev); 300 301 return 0; 302 } 303 304 static struct platform_driver exynos_drm_platform_driver = { 305 .probe = exynos_drm_platform_probe, 306 .remove = exynos_drm_platform_remove, 307 .driver = { 308 .owner = THIS_MODULE, 309 .name = "exynos-drm", 310 }, 311 }; 312 313 static int __init exynos_drm_init(void) 314 { 315 int ret; 316 317 #ifdef CONFIG_DRM_EXYNOS_FIMD 318 ret = platform_driver_register(&fimd_driver); 319 if (ret < 0) 320 goto out_fimd; 321 #endif 322 323 #ifdef CONFIG_DRM_EXYNOS_HDMI 324 ret = platform_driver_register(&hdmi_driver); 325 if (ret < 0) 326 goto out_hdmi; 327 ret = platform_driver_register(&mixer_driver); 328 if (ret < 0) 329 goto out_mixer; 330 ret = platform_driver_register(&exynos_drm_common_hdmi_driver); 331 if (ret < 0) 332 goto out_common_hdmi; 333 334 ret = exynos_platform_device_hdmi_register(); 335 if (ret < 0) 336 goto out_common_hdmi_dev; 337 #endif 338 339 #ifdef CONFIG_DRM_EXYNOS_VIDI 340 ret = platform_driver_register(&vidi_driver); 341 if (ret < 0) 342 goto out_vidi; 343 #endif 344 345 #ifdef CONFIG_DRM_EXYNOS_G2D 346 ret = platform_driver_register(&g2d_driver); 347 if (ret < 0) 348 goto out_g2d; 349 #endif 350 351 #ifdef CONFIG_DRM_EXYNOS_FIMC 352 ret = platform_driver_register(&fimc_driver); 353 if (ret < 0) 354 goto out_fimc; 355 #endif 356 357 #ifdef CONFIG_DRM_EXYNOS_ROTATOR 358 ret = platform_driver_register(&rotator_driver); 359 if (ret < 0) 360 goto out_rotator; 361 #endif 362 363 #ifdef CONFIG_DRM_EXYNOS_GSC 364 ret = platform_driver_register(&gsc_driver); 365 if (ret < 0) 366 goto out_gsc; 367 #endif 368 369 #ifdef CONFIG_DRM_EXYNOS_IPP 370 ret = platform_driver_register(&ipp_driver); 371 if (ret < 0) 372 goto out_ipp; 373 374 ret = exynos_platform_device_ipp_register(); 375 if (ret < 0) 376 goto out_ipp_dev; 377 #endif 378 379 ret = platform_driver_register(&exynos_drm_platform_driver); 380 if (ret < 0) 381 goto out_drm; 382 383 exynos_drm_pdev = platform_device_register_simple("exynos-drm", -1, 384 NULL, 0); 385 if (IS_ERR(exynos_drm_pdev)) { 386 ret = PTR_ERR(exynos_drm_pdev); 387 goto out; 388 } 389 390 return 0; 391 392 out: 393 platform_driver_unregister(&exynos_drm_platform_driver); 394 395 out_drm: 396 #ifdef CONFIG_DRM_EXYNOS_IPP 397 exynos_platform_device_ipp_unregister(); 398 out_ipp_dev: 399 platform_driver_unregister(&ipp_driver); 400 out_ipp: 401 #endif 402 403 #ifdef CONFIG_DRM_EXYNOS_GSC 404 platform_driver_unregister(&gsc_driver); 405 out_gsc: 406 #endif 407 408 #ifdef CONFIG_DRM_EXYNOS_ROTATOR 409 platform_driver_unregister(&rotator_driver); 410 out_rotator: 411 #endif 412 413 #ifdef CONFIG_DRM_EXYNOS_FIMC 414 platform_driver_unregister(&fimc_driver); 415 out_fimc: 416 #endif 417 418 #ifdef CONFIG_DRM_EXYNOS_G2D 419 platform_driver_unregister(&g2d_driver); 420 out_g2d: 421 #endif 422 423 #ifdef CONFIG_DRM_EXYNOS_VIDI 424 platform_driver_unregister(&vidi_driver); 425 out_vidi: 426 #endif 427 428 #ifdef CONFIG_DRM_EXYNOS_HDMI 429 exynos_platform_device_hdmi_unregister(); 430 out_common_hdmi_dev: 431 platform_driver_unregister(&exynos_drm_common_hdmi_driver); 432 out_common_hdmi: 433 platform_driver_unregister(&mixer_driver); 434 out_mixer: 435 platform_driver_unregister(&hdmi_driver); 436 out_hdmi: 437 #endif 438 439 #ifdef CONFIG_DRM_EXYNOS_FIMD 440 platform_driver_unregister(&fimd_driver); 441 out_fimd: 442 #endif 443 return ret; 444 } 445 446 static void __exit exynos_drm_exit(void) 447 { 448 platform_device_unregister(exynos_drm_pdev); 449 450 platform_driver_unregister(&exynos_drm_platform_driver); 451 452 #ifdef CONFIG_DRM_EXYNOS_IPP 453 exynos_platform_device_ipp_unregister(); 454 platform_driver_unregister(&ipp_driver); 455 #endif 456 457 #ifdef CONFIG_DRM_EXYNOS_GSC 458 platform_driver_unregister(&gsc_driver); 459 #endif 460 461 #ifdef CONFIG_DRM_EXYNOS_ROTATOR 462 platform_driver_unregister(&rotator_driver); 463 #endif 464 465 #ifdef CONFIG_DRM_EXYNOS_FIMC 466 platform_driver_unregister(&fimc_driver); 467 #endif 468 469 #ifdef CONFIG_DRM_EXYNOS_G2D 470 platform_driver_unregister(&g2d_driver); 471 #endif 472 473 #ifdef CONFIG_DRM_EXYNOS_HDMI 474 exynos_platform_device_hdmi_unregister(); 475 platform_driver_unregister(&exynos_drm_common_hdmi_driver); 476 platform_driver_unregister(&mixer_driver); 477 platform_driver_unregister(&hdmi_driver); 478 #endif 479 480 #ifdef CONFIG_DRM_EXYNOS_VIDI 481 platform_driver_unregister(&vidi_driver); 482 #endif 483 484 #ifdef CONFIG_DRM_EXYNOS_FIMD 485 platform_driver_unregister(&fimd_driver); 486 #endif 487 } 488 489 module_init(exynos_drm_init); 490 module_exit(exynos_drm_exit); 491 492 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>"); 493 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>"); 494 MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>"); 495 MODULE_DESCRIPTION("Samsung SoC DRM Driver"); 496 MODULE_LICENSE("GPL"); 497