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