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_init_object = exynos_drm_gem_init_object, 268 .gem_free_object = exynos_drm_gem_free_object, 269 .gem_vm_ops = &exynos_drm_gem_vm_ops, 270 .dumb_create = exynos_drm_gem_dumb_create, 271 .dumb_map_offset = exynos_drm_gem_dumb_map_offset, 272 .dumb_destroy = drm_gem_dumb_destroy, 273 .prime_handle_to_fd = drm_gem_prime_handle_to_fd, 274 .prime_fd_to_handle = drm_gem_prime_fd_to_handle, 275 .gem_prime_export = exynos_dmabuf_prime_export, 276 .gem_prime_import = exynos_dmabuf_prime_import, 277 .ioctls = exynos_ioctls, 278 .num_ioctls = ARRAY_SIZE(exynos_ioctls), 279 .fops = &exynos_drm_driver_fops, 280 .name = DRIVER_NAME, 281 .desc = DRIVER_DESC, 282 .date = DRIVER_DATE, 283 .major = DRIVER_MAJOR, 284 .minor = DRIVER_MINOR, 285 }; 286 287 static int exynos_drm_platform_probe(struct platform_device *pdev) 288 { 289 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 290 291 return drm_platform_init(&exynos_drm_driver, pdev); 292 } 293 294 static int exynos_drm_platform_remove(struct platform_device *pdev) 295 { 296 drm_platform_exit(&exynos_drm_driver, pdev); 297 298 return 0; 299 } 300 301 static struct platform_driver exynos_drm_platform_driver = { 302 .probe = exynos_drm_platform_probe, 303 .remove = exynos_drm_platform_remove, 304 .driver = { 305 .owner = THIS_MODULE, 306 .name = "exynos-drm", 307 }, 308 }; 309 310 static int __init exynos_drm_init(void) 311 { 312 int ret; 313 314 #ifdef CONFIG_DRM_EXYNOS_FIMD 315 ret = platform_driver_register(&fimd_driver); 316 if (ret < 0) 317 goto out_fimd; 318 #endif 319 320 #ifdef CONFIG_DRM_EXYNOS_HDMI 321 ret = platform_driver_register(&hdmi_driver); 322 if (ret < 0) 323 goto out_hdmi; 324 ret = platform_driver_register(&mixer_driver); 325 if (ret < 0) 326 goto out_mixer; 327 ret = platform_driver_register(&exynos_drm_common_hdmi_driver); 328 if (ret < 0) 329 goto out_common_hdmi; 330 331 ret = exynos_platform_device_hdmi_register(); 332 if (ret < 0) 333 goto out_common_hdmi_dev; 334 #endif 335 336 #ifdef CONFIG_DRM_EXYNOS_VIDI 337 ret = platform_driver_register(&vidi_driver); 338 if (ret < 0) 339 goto out_vidi; 340 #endif 341 342 #ifdef CONFIG_DRM_EXYNOS_G2D 343 ret = platform_driver_register(&g2d_driver); 344 if (ret < 0) 345 goto out_g2d; 346 #endif 347 348 #ifdef CONFIG_DRM_EXYNOS_FIMC 349 ret = platform_driver_register(&fimc_driver); 350 if (ret < 0) 351 goto out_fimc; 352 #endif 353 354 #ifdef CONFIG_DRM_EXYNOS_ROTATOR 355 ret = platform_driver_register(&rotator_driver); 356 if (ret < 0) 357 goto out_rotator; 358 #endif 359 360 #ifdef CONFIG_DRM_EXYNOS_GSC 361 ret = platform_driver_register(&gsc_driver); 362 if (ret < 0) 363 goto out_gsc; 364 #endif 365 366 #ifdef CONFIG_DRM_EXYNOS_IPP 367 ret = platform_driver_register(&ipp_driver); 368 if (ret < 0) 369 goto out_ipp; 370 371 ret = exynos_platform_device_ipp_register(); 372 if (ret < 0) 373 goto out_ipp_dev; 374 #endif 375 376 ret = platform_driver_register(&exynos_drm_platform_driver); 377 if (ret < 0) 378 goto out_drm; 379 380 exynos_drm_pdev = platform_device_register_simple("exynos-drm", -1, 381 NULL, 0); 382 if (IS_ERR(exynos_drm_pdev)) { 383 ret = PTR_ERR(exynos_drm_pdev); 384 goto out; 385 } 386 387 return 0; 388 389 out: 390 platform_driver_unregister(&exynos_drm_platform_driver); 391 392 out_drm: 393 #ifdef CONFIG_DRM_EXYNOS_IPP 394 exynos_platform_device_ipp_unregister(); 395 out_ipp_dev: 396 platform_driver_unregister(&ipp_driver); 397 out_ipp: 398 #endif 399 400 #ifdef CONFIG_DRM_EXYNOS_GSC 401 platform_driver_unregister(&gsc_driver); 402 out_gsc: 403 #endif 404 405 #ifdef CONFIG_DRM_EXYNOS_ROTATOR 406 platform_driver_unregister(&rotator_driver); 407 out_rotator: 408 #endif 409 410 #ifdef CONFIG_DRM_EXYNOS_FIMC 411 platform_driver_unregister(&fimc_driver); 412 out_fimc: 413 #endif 414 415 #ifdef CONFIG_DRM_EXYNOS_G2D 416 platform_driver_unregister(&g2d_driver); 417 out_g2d: 418 #endif 419 420 #ifdef CONFIG_DRM_EXYNOS_VIDI 421 platform_driver_unregister(&vidi_driver); 422 out_vidi: 423 #endif 424 425 #ifdef CONFIG_DRM_EXYNOS_HDMI 426 exynos_platform_device_hdmi_unregister(); 427 out_common_hdmi_dev: 428 platform_driver_unregister(&exynos_drm_common_hdmi_driver); 429 out_common_hdmi: 430 platform_driver_unregister(&mixer_driver); 431 out_mixer: 432 platform_driver_unregister(&hdmi_driver); 433 out_hdmi: 434 #endif 435 436 #ifdef CONFIG_DRM_EXYNOS_FIMD 437 platform_driver_unregister(&fimd_driver); 438 out_fimd: 439 #endif 440 return ret; 441 } 442 443 static void __exit exynos_drm_exit(void) 444 { 445 platform_device_unregister(exynos_drm_pdev); 446 447 platform_driver_unregister(&exynos_drm_platform_driver); 448 449 #ifdef CONFIG_DRM_EXYNOS_IPP 450 exynos_platform_device_ipp_unregister(); 451 platform_driver_unregister(&ipp_driver); 452 #endif 453 454 #ifdef CONFIG_DRM_EXYNOS_GSC 455 platform_driver_unregister(&gsc_driver); 456 #endif 457 458 #ifdef CONFIG_DRM_EXYNOS_ROTATOR 459 platform_driver_unregister(&rotator_driver); 460 #endif 461 462 #ifdef CONFIG_DRM_EXYNOS_FIMC 463 platform_driver_unregister(&fimc_driver); 464 #endif 465 466 #ifdef CONFIG_DRM_EXYNOS_G2D 467 platform_driver_unregister(&g2d_driver); 468 #endif 469 470 #ifdef CONFIG_DRM_EXYNOS_HDMI 471 exynos_platform_device_hdmi_unregister(); 472 platform_driver_unregister(&exynos_drm_common_hdmi_driver); 473 platform_driver_unregister(&mixer_driver); 474 platform_driver_unregister(&hdmi_driver); 475 #endif 476 477 #ifdef CONFIG_DRM_EXYNOS_VIDI 478 platform_driver_unregister(&vidi_driver); 479 #endif 480 481 #ifdef CONFIG_DRM_EXYNOS_FIMD 482 platform_driver_unregister(&fimd_driver); 483 #endif 484 } 485 486 module_init(exynos_drm_init); 487 module_exit(exynos_drm_exit); 488 489 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>"); 490 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>"); 491 MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>"); 492 MODULE_DESCRIPTION("Samsung SoC DRM Driver"); 493 MODULE_LICENSE("GPL"); 494