drm/exynos/exynos_drm_drv.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
0004  * Authors:
0005  *  Inki Dae <inki.dae@samsung.com>
0006  *  Joonyoung Shim <jy0922.shim@samsung.com>
0007  *  Seung-Woo Kim <sw0312.kim@samsung.com>
0008  */
0009
0010 #include <linux/component.h>
0011 #include <linux/dma-mapping.h>
0012 #include <linux/platform_device.h>
0013 #include <linux/pm_runtime.h>
0014 #include <linux/uaccess.h>
0015
0016 #include <drm/drm_atomic.h>
0017 #include <drm/drm_atomic_helper.h>
0018 #include <drm/drm_drv.h>
0019 #include <drm/drm_fb_helper.h>
0020 #include <drm/drm_file.h>
0021 #include <drm/drm_fourcc.h>
0022 #include <drm/drm_ioctl.h>
0023 #include <drm/drm_probe_helper.h>
0024 #include <drm/drm_vblank.h>
0025 #include <drm/exynos_drm.h>
0026
0027 #include "exynos_drm_drv.h"
0028 #include "exynos_drm_fb.h"
0029 #include "exynos_drm_fbdev.h"
0030 #include "exynos_drm_g2d.h"
0031 #include "exynos_drm_gem.h"
0032 #include "exynos_drm_ipp.h"
0033 #include "exynos_drm_plane.h"
0034 #include "exynos_drm_vidi.h"
0035
0036 #define DRIVER_NAME "exynos"
0037 #define DRIVER_DESC "Samsung SoC DRM"
0038 #define DRIVER_DATE "20180330"
0039
0040 /*
0041  * Interface history:
0042  *
0043  * 1.0 - Original version
0044  * 1.1 - Upgrade IPP driver to version 2.0
0045  */
0046 #define DRIVER_MAJOR    1
0047 #define DRIVER_MINOR    1
0048
0049 static int exynos_drm_open(struct drm_device *dev, struct drm_file *file)
0050 {
0051     struct drm_exynos_file_private *file_priv;
0052     int ret;
0053
0054     file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
0055     if (!file_priv)
0056         return -ENOMEM;
0057
0058     file->driver_priv = file_priv;
0059     ret = g2d_open(dev, file);
0060     if (ret)
0061         goto err_file_priv_free;
0062
0063     return ret;
0064
0065 err_file_priv_free:
0066     kfree(file_priv);
0067     file->driver_priv = NULL;
0068     return ret;
0069 }
0070
0071 static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
0072 {
0073     g2d_close(dev, file);
0074     kfree(file->driver_priv);
0075     file->driver_priv = NULL;
0076 }
0077
0078 static const struct drm_ioctl_desc exynos_ioctls[] = {
0079     DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl,
0080             DRM_RENDER_ALLOW),
0081     DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MAP, exynos_drm_gem_map_ioctl,
0082             DRM_RENDER_ALLOW),
0083     DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET, exynos_drm_gem_get_ioctl,
0084             DRM_RENDER_ALLOW),
0085     DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION, vidi_connection_ioctl,
0086             DRM_AUTH),
0087     DRM_IOCTL_DEF_DRV(EXYNOS_G2D_GET_VER, exynos_g2d_get_ver_ioctl,
0088             DRM_RENDER_ALLOW),
0089     DRM_IOCTL_DEF_DRV(EXYNOS_G2D_SET_CMDLIST, exynos_g2d_set_cmdlist_ioctl,
0090             DRM_RENDER_ALLOW),
0091     DRM_IOCTL_DEF_DRV(EXYNOS_G2D_EXEC, exynos_g2d_exec_ioctl,
0092             DRM_RENDER_ALLOW),
0093     DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_RESOURCES,
0094             exynos_drm_ipp_get_res_ioctl,
0095             DRM_RENDER_ALLOW),
0096     DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_CAPS, exynos_drm_ipp_get_caps_ioctl,
0097             DRM_RENDER_ALLOW),
0098     DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_LIMITS,
0099             exynos_drm_ipp_get_limits_ioctl,
0100             DRM_RENDER_ALLOW),
0101     DRM_IOCTL_DEF_DRV(EXYNOS_IPP_COMMIT, exynos_drm_ipp_commit_ioctl,
0102             DRM_RENDER_ALLOW),
0103 };
0104
0105 DEFINE_DRM_GEM_FOPS(exynos_drm_driver_fops);
0106
0107 static const struct drm_driver exynos_drm_driver = {
0108     .driver_features    = DRIVER_MODESET | DRIVER_GEM
0109                   | DRIVER_ATOMIC | DRIVER_RENDER,
0110     .open           = exynos_drm_open,
0111     .lastclose      = drm_fb_helper_lastclose,
0112     .postclose      = exynos_drm_postclose,
0113     .dumb_create        = exynos_drm_gem_dumb_create,
0114     .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
0115     .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
0116     .gem_prime_import   = exynos_drm_gem_prime_import,
0117     .gem_prime_import_sg_table  = exynos_drm_gem_prime_import_sg_table,
0118     .gem_prime_mmap     = drm_gem_prime_mmap,
0119     .ioctls         = exynos_ioctls,
0120     .num_ioctls     = ARRAY_SIZE(exynos_ioctls),
0121     .fops           = &exynos_drm_driver_fops,
0122     .name   = DRIVER_NAME,
0123     .desc   = DRIVER_DESC,
0124     .date   = DRIVER_DATE,
0125     .major  = DRIVER_MAJOR,
0126     .minor  = DRIVER_MINOR,
0127 };
0128
0129 static int exynos_drm_suspend(struct device *dev)
0130 {
0131     struct drm_device *drm_dev = dev_get_drvdata(dev);
0132
0133     return  drm_mode_config_helper_suspend(drm_dev);
0134 }
0135
0136 static void exynos_drm_resume(struct device *dev)
0137 {
0138     struct drm_device *drm_dev = dev_get_drvdata(dev);
0139
0140     drm_mode_config_helper_resume(drm_dev);
0141 }
0142
0143 static const struct dev_pm_ops exynos_drm_pm_ops = {
0144     .prepare = exynos_drm_suspend,
0145     .complete = exynos_drm_resume,
0146 };
0147
0148 /* forward declaration */
0149 static struct platform_driver exynos_drm_platform_driver;
0150
0151 struct exynos_drm_driver_info {
0152     struct platform_driver *driver;
0153     unsigned int flags;
0154 };
0155
0156 #define DRM_COMPONENT_DRIVER    BIT(0)  /* supports component framework */
0157 #define DRM_VIRTUAL_DEVICE  BIT(1)  /* create virtual platform device */
0158 #define DRM_FIMC_DEVICE     BIT(2)  /* devices shared with V4L2 subsystem */
0159
0160 #define DRV_PTR(drv, cond) (IS_ENABLED(cond) ? &drv : NULL)
0161
0162 /*
0163  * Connector drivers should not be placed before associated crtc drivers,
0164  * because connector requires pipe number of its crtc during initialization.
0165  */
0166 static struct exynos_drm_driver_info exynos_drm_drivers[] = {
0167     {
0168         DRV_PTR(fimd_driver, CONFIG_DRM_EXYNOS_FIMD),
0169         DRM_COMPONENT_DRIVER
0170     }, {
0171         DRV_PTR(exynos5433_decon_driver, CONFIG_DRM_EXYNOS5433_DECON),
0172         DRM_COMPONENT_DRIVER
0173     }, {
0174         DRV_PTR(decon_driver, CONFIG_DRM_EXYNOS7_DECON),
0175         DRM_COMPONENT_DRIVER
0176     }, {
0177         DRV_PTR(mixer_driver, CONFIG_DRM_EXYNOS_MIXER),
0178         DRM_COMPONENT_DRIVER
0179     }, {
0180         DRV_PTR(dp_driver, CONFIG_DRM_EXYNOS_DP),
0181         DRM_COMPONENT_DRIVER
0182     }, {
0183         DRV_PTR(dsi_driver, CONFIG_DRM_EXYNOS_DSI),
0184         DRM_COMPONENT_DRIVER
0185     }, {
0186         DRV_PTR(mic_driver, CONFIG_DRM_EXYNOS_MIC),
0187         DRM_COMPONENT_DRIVER
0188     }, {
0189         DRV_PTR(hdmi_driver, CONFIG_DRM_EXYNOS_HDMI),
0190         DRM_COMPONENT_DRIVER
0191     }, {
0192         DRV_PTR(vidi_driver, CONFIG_DRM_EXYNOS_VIDI),
0193         DRM_COMPONENT_DRIVER | DRM_VIRTUAL_DEVICE
0194     }, {
0195         DRV_PTR(g2d_driver, CONFIG_DRM_EXYNOS_G2D),
0196         DRM_COMPONENT_DRIVER
0197     }, {
0198         DRV_PTR(fimc_driver, CONFIG_DRM_EXYNOS_FIMC),
0199         DRM_COMPONENT_DRIVER | DRM_FIMC_DEVICE,
0200     }, {
0201         DRV_PTR(rotator_driver, CONFIG_DRM_EXYNOS_ROTATOR),
0202         DRM_COMPONENT_DRIVER
0203     }, {
0204         DRV_PTR(scaler_driver, CONFIG_DRM_EXYNOS_SCALER),
0205         DRM_COMPONENT_DRIVER
0206     }, {
0207         DRV_PTR(gsc_driver, CONFIG_DRM_EXYNOS_GSC),
0208         DRM_COMPONENT_DRIVER
0209     }, {
0210         &exynos_drm_platform_driver,
0211         DRM_VIRTUAL_DEVICE
0212     }
0213 };
0214
0215 static struct component_match *exynos_drm_match_add(struct device *dev)
0216 {
0217     struct component_match *match = NULL;
0218     int i;
0219
0220     for (i = 0; i < ARRAY_SIZE(exynos_drm_drivers); ++i) {
0221         struct exynos_drm_driver_info *info = &exynos_drm_drivers[i];
0222         struct device *p = NULL, *d;
0223
0224         if (!info->driver || !(info->flags & DRM_COMPONENT_DRIVER))
0225             continue;
0226
0227         while ((d = platform_find_device_by_driver(p, &info->driver->driver))) {
0228             put_device(p);
0229
0230             if (!(info->flags & DRM_FIMC_DEVICE) ||
0231                 exynos_drm_check_fimc_device(d) == 0)
0232                 component_match_add(dev, &match, component_compare_dev, d);
0233             p = d;
0234         }
0235         put_device(p);
0236     }
0237
0238     return match ?: ERR_PTR(-ENODEV);
0239 }
0240
0241 static int exynos_drm_bind(struct device *dev)
0242 {
0243     struct exynos_drm_private *private;
0244     struct drm_encoder *encoder;
0245     struct drm_device *drm;
0246     unsigned int clone_mask;
0247     int ret;
0248
0249     drm = drm_dev_alloc(&exynos_drm_driver, dev);
0250     if (IS_ERR(drm))
0251         return PTR_ERR(drm);
0252
0253     private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL);
0254     if (!private) {
0255         ret = -ENOMEM;
0256         goto err_free_drm;
0257     }
0258
0259     init_waitqueue_head(&private->wait);
0260     spin_lock_init(&private->lock);
0261
0262     dev_set_drvdata(dev, drm);
0263     drm->dev_private = (void *)private;
0264
0265     drm_mode_config_init(drm);
0266
0267     exynos_drm_mode_config_init(drm);
0268
0269     /* setup possible_clones. */
0270     clone_mask = 0;
0271     list_for_each_entry(encoder, &drm->mode_config.encoder_list, head)
0272         clone_mask |= drm_encoder_mask(encoder);
0273
0274     list_for_each_entry(encoder, &drm->mode_config.encoder_list, head)
0275         encoder->possible_clones = clone_mask;
0276
0277     /* Try to bind all sub drivers. */
0278     ret = component_bind_all(drm->dev, drm);
0279     if (ret)
0280         goto err_mode_config_cleanup;
0281
0282     ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
0283     if (ret)
0284         goto err_unbind_all;
0285
0286     drm_mode_config_reset(drm);
0287
0288     /* init kms poll for handling hpd */
0289     drm_kms_helper_poll_init(drm);
0290
0291     ret = exynos_drm_fbdev_init(drm);
0292     if (ret)
0293         goto err_cleanup_poll;
0294
0295     /* register the DRM device */
0296     ret = drm_dev_register(drm, 0);
0297     if (ret < 0)
0298         goto err_cleanup_fbdev;
0299
0300     return 0;
0301
0302 err_cleanup_fbdev:
0303     exynos_drm_fbdev_fini(drm);
0304 err_cleanup_poll:
0305     drm_kms_helper_poll_fini(drm);
0306 err_unbind_all:
0307     component_unbind_all(drm->dev, drm);
0308 err_mode_config_cleanup:
0309     drm_mode_config_cleanup(drm);
0310     exynos_drm_cleanup_dma(drm);
0311     kfree(private);
0312 err_free_drm:
0313     drm_dev_put(drm);
0314
0315     return ret;
0316 }
0317
0318 static void exynos_drm_unbind(struct device *dev)
0319 {
0320     struct drm_device *drm = dev_get_drvdata(dev);
0321
0322     drm_dev_unregister(drm);
0323
0324     exynos_drm_fbdev_fini(drm);
0325     drm_kms_helper_poll_fini(drm);
0326
0327     component_unbind_all(drm->dev, drm);
0328     drm_mode_config_cleanup(drm);
0329     exynos_drm_cleanup_dma(drm);
0330
0331     kfree(drm->dev_private);
0332     drm->dev_private = NULL;
0333     dev_set_drvdata(dev, NULL);
0334
0335     drm_dev_put(drm);
0336 }
0337
0338 static const struct component_master_ops exynos_drm_ops = {
0339     .bind       = exynos_drm_bind,
0340     .unbind     = exynos_drm_unbind,
0341 };
0342
0343 static int exynos_drm_platform_probe(struct platform_device *pdev)
0344 {
0345     struct component_match *match;
0346
0347     pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
0348
0349     match = exynos_drm_match_add(&pdev->dev);
0350     if (IS_ERR(match))
0351         return PTR_ERR(match);
0352
0353     return component_master_add_with_match(&pdev->dev, &exynos_drm_ops,
0354                            match);
0355 }
0356
0357 static int exynos_drm_platform_remove(struct platform_device *pdev)
0358 {
0359     component_master_del(&pdev->dev, &exynos_drm_ops);
0360     return 0;
0361 }
0362
0363 static struct platform_driver exynos_drm_platform_driver = {
0364     .probe  = exynos_drm_platform_probe,
0365     .remove = exynos_drm_platform_remove,
0366     .driver = {
0367         .name   = "exynos-drm",
0368         .pm = &exynos_drm_pm_ops,
0369     },
0370 };
0371
0372 static void exynos_drm_unregister_devices(void)
0373 {
0374     int i;
0375
0376     for (i = ARRAY_SIZE(exynos_drm_drivers) - 1; i >= 0; --i) {
0377         struct exynos_drm_driver_info *info = &exynos_drm_drivers[i];
0378         struct device *dev;
0379
0380         if (!info->driver || !(info->flags & DRM_VIRTUAL_DEVICE))
0381             continue;
0382
0383         while ((dev = platform_find_device_by_driver(NULL,
0384                         &info->driver->driver))) {
0385             put_device(dev);
0386             platform_device_unregister(to_platform_device(dev));
0387         }
0388     }
0389 }
0390
0391 static int exynos_drm_register_devices(void)
0392 {
0393     struct platform_device *pdev;
0394     int i;
0395
0396     for (i = 0; i < ARRAY_SIZE(exynos_drm_drivers); ++i) {
0397         struct exynos_drm_driver_info *info = &exynos_drm_drivers[i];
0398
0399         if (!info->driver || !(info->flags & DRM_VIRTUAL_DEVICE))
0400             continue;
0401
0402         pdev = platform_device_register_simple(
0403                     info->driver->driver.name, -1, NULL, 0);
0404         if (IS_ERR(pdev))
0405             goto fail;
0406     }
0407
0408     return 0;
0409 fail:
0410     exynos_drm_unregister_devices();
0411     return PTR_ERR(pdev);
0412 }
0413
0414 static void exynos_drm_unregister_drivers(void)
0415 {
0416     int i;
0417
0418     for (i = ARRAY_SIZE(exynos_drm_drivers) - 1; i >= 0; --i) {
0419         struct exynos_drm_driver_info *info = &exynos_drm_drivers[i];
0420
0421         if (!info->driver)
0422             continue;
0423
0424         platform_driver_unregister(info->driver);
0425     }
0426 }
0427
0428 static int exynos_drm_register_drivers(void)
0429 {
0430     int i, ret;
0431
0432     for (i = 0; i < ARRAY_SIZE(exynos_drm_drivers); ++i) {
0433         struct exynos_drm_driver_info *info = &exynos_drm_drivers[i];
0434
0435         if (!info->driver)
0436             continue;
0437
0438         ret = platform_driver_register(info->driver);
0439         if (ret)
0440             goto fail;
0441     }
0442     return 0;
0443 fail:
0444     exynos_drm_unregister_drivers();
0445     return ret;
0446 }
0447
0448 static int exynos_drm_init(void)
0449 {
0450     int ret;
0451
0452     if (drm_firmware_drivers_only())
0453         return -ENODEV;
0454
0455     ret = exynos_drm_register_devices();
0456     if (ret)
0457         return ret;
0458
0459     ret = exynos_drm_register_drivers();
0460     if (ret)
0461         goto err_unregister_pdevs;
0462
0463     return 0;
0464
0465 err_unregister_pdevs:
0466     exynos_drm_unregister_devices();
0467
0468     return ret;
0469 }
0470
0471 static void exynos_drm_exit(void)
0472 {
0473     exynos_drm_unregister_drivers();
0474     exynos_drm_unregister_devices();
0475 }
0476
0477 module_init(exynos_drm_init);
0478 module_exit(exynos_drm_exit);
0479
0480 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
0481 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
0482 MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
0483 MODULE_DESCRIPTION("Samsung SoC DRM Driver");
0484 MODULE_LICENSE("GPL");