exynos_drm_drv.c 12 KB

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