[deliverable/linux.git] / drivers / gpu / drm / exynos / exynos_drm_drv.c

/*
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 * Authors:
 *	Inki Dae <inki.dae@samsung.com>
 *	Joonyoung Shim <jy0922.shim@samsung.com>
 *	Seung-Woo Kim <sw0312.kim@samsung.com>
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

#include <drm/drmP.h>
#include <drm/drm_crtc_helper.h>

#include <drm/exynos_drm.h>

#include "exynos_drm_drv.h"
#include "exynos_drm_crtc.h"
#include "exynos_drm_encoder.h"
#include "exynos_drm_fbdev.h"
#include "exynos_drm_fb.h"
#include "exynos_drm_gem.h"
#include "exynos_drm_plane.h"
#include "exynos_drm_vidi.h"
#include "exynos_drm_dmabuf.h"
#include "exynos_drm_g2d.h"
#include "exynos_drm_ipp.h"
#include "exynos_drm_iommu.h"

#define DRIVER_NAME	"exynos"
#define DRIVER_DESC	"Samsung SoC DRM"
#define DRIVER_DATE	"20110530"
#define DRIVER_MAJOR	1
#define DRIVER_MINOR	0

#define VBLANK_OFF_DELAY	50000

/* platform device pointer for eynos drm device. */
static struct platform_device *exynos_drm_pdev;

static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
{
	struct exynos_drm_private *private;
	int ret;
	int nr;

	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL);
	if (!private) {
		DRM_ERROR("failed to allocate private\n");
		return -ENOMEM;
	}

	INIT_LIST_HEAD(&private->pageflip_event_list);
	dev->dev_private = (void *)private;

	/*
	 * create mapping to manage iommu table and set a pointer to iommu
	 * mapping structure to iommu_mapping of private data.
	 * also this iommu_mapping can be used to check if iommu is supported
	 * or not.
	 */
	ret = drm_create_iommu_mapping(dev);
	if (ret < 0) {
		DRM_ERROR("failed to create iommu mapping.\n");
		goto err_crtc;
	}

	drm_mode_config_init(dev);

	/* init kms poll for handling hpd */
	drm_kms_helper_poll_init(dev);

	exynos_drm_mode_config_init(dev);

	/*
	 * EXYNOS4 is enough to have two CRTCs and each crtc would be used
	 * without dependency of hardware.
	 */
	for (nr = 0; nr < MAX_CRTC; nr++) {
		ret = exynos_drm_crtc_create(dev, nr);
		if (ret)
			goto err_release_iommu_mapping;
	}

	for (nr = 0; nr < MAX_PLANE; nr++) {
		struct drm_plane *plane;
		unsigned int possible_crtcs = (1 << MAX_CRTC) - 1;

		plane = exynos_plane_init(dev, possible_crtcs, false);
		if (!plane)
			goto err_release_iommu_mapping;
	}

	ret = drm_vblank_init(dev, MAX_CRTC);
	if (ret)
		goto err_release_iommu_mapping;

	/*
	 * probe sub drivers such as display controller and hdmi driver,
	 * that were registered at probe() of platform driver
	 * to the sub driver and create encoder and connector for them.
	 */
	ret = exynos_drm_device_register(dev);
	if (ret)
		goto err_vblank;

	/* setup possible_clones. */
	exynos_drm_encoder_setup(dev);

	/*
	 * create and configure fb helper and also exynos specific
	 * fbdev object.
	 */
	ret = exynos_drm_fbdev_init(dev);
	if (ret) {
		DRM_ERROR("failed to initialize drm fbdev\n");
		goto err_drm_device;
	}

	drm_vblank_offdelay = VBLANK_OFF_DELAY;

	return 0;

err_drm_device:
	exynos_drm_device_unregister(dev);
err_vblank:
	drm_vblank_cleanup(dev);
err_release_iommu_mapping:
	drm_release_iommu_mapping(dev);
err_crtc:
	drm_mode_config_cleanup(dev);
	kfree(private);

	return ret;
}

static int exynos_drm_unload(struct drm_device *dev)
{
	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	exynos_drm_fbdev_fini(dev);
	exynos_drm_device_unregister(dev);
	drm_vblank_cleanup(dev);
	drm_kms_helper_poll_fini(dev);
	drm_mode_config_cleanup(dev);

	drm_release_iommu_mapping(dev);
	kfree(dev->dev_private);

	dev->dev_private = NULL;

	return 0;
}

static int exynos_drm_open(struct drm_device *dev, struct drm_file *file)
{
	struct drm_exynos_file_private *file_priv;

	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
	if (!file_priv)
		return -ENOMEM;

	file->driver_priv = file_priv;

	return exynos_drm_subdrv_open(dev, file);
}

static void exynos_drm_preclose(struct drm_device *dev,
					struct drm_file *file)
{
	struct exynos_drm_private *private = dev->dev_private;
	struct drm_pending_vblank_event *e, *t;
	unsigned long flags;

	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	/* release events of current file */
	spin_lock_irqsave(&dev->event_lock, flags);
	list_for_each_entry_safe(e, t, &private->pageflip_event_list,
			base.link) {
		if (e->base.file_priv == file) {
			list_del(&e->base.link);
			e->base.destroy(&e->base);
		}
	}
	spin_unlock_irqrestore(&dev->event_lock, flags);

	exynos_drm_subdrv_close(dev, file);
}

static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
{
	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	if (!file->driver_priv)
		return;

	kfree(file->driver_priv);
	file->driver_priv = NULL;
}

static void exynos_drm_lastclose(struct drm_device *dev)
{
	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	exynos_drm_fbdev_restore_mode(dev);
}

static const struct vm_operations_struct exynos_drm_gem_vm_ops = {
	.fault = exynos_drm_gem_fault,
	.open = drm_gem_vm_open,
	.close = drm_gem_vm_close,
};

static struct drm_ioctl_desc exynos_ioctls[] = {
	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl,
			DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MAP_OFFSET,
			exynos_drm_gem_map_offset_ioctl, DRM_UNLOCKED |
			DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MMAP,
			exynos_drm_gem_mmap_ioctl, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET,
			exynos_drm_gem_get_ioctl, DRM_UNLOCKED),
	DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION,
			vidi_connection_ioctl, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_GET_VER,
			exynos_g2d_get_ver_ioctl, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_SET_CMDLIST,
			exynos_g2d_set_cmdlist_ioctl, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_EXEC,
			exynos_g2d_exec_ioctl, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_PROPERTY,
			exynos_drm_ipp_get_property, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_IPP_SET_PROPERTY,
			exynos_drm_ipp_set_property, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_IPP_QUEUE_BUF,
			exynos_drm_ipp_queue_buf, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_IPP_CMD_CTRL,
			exynos_drm_ipp_cmd_ctrl, DRM_UNLOCKED | DRM_AUTH),
};

static const struct file_operations exynos_drm_driver_fops = {
	.owner		= THIS_MODULE,
	.open		= drm_open,
	.mmap		= exynos_drm_gem_mmap,
	.poll		= drm_poll,
	.read		= drm_read,
	.unlocked_ioctl	= drm_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = drm_compat_ioctl,
#endif
	.release	= drm_release,
};

static struct drm_driver exynos_drm_driver = {
	.driver_features	= DRIVER_HAVE_IRQ | DRIVER_MODESET |
					DRIVER_GEM | DRIVER_PRIME,
	.load			= exynos_drm_load,
	.unload			= exynos_drm_unload,
	.open			= exynos_drm_open,
	.preclose		= exynos_drm_preclose,
	.lastclose		= exynos_drm_lastclose,
	.postclose		= exynos_drm_postclose,
	.get_vblank_counter	= drm_vblank_count,
	.enable_vblank		= exynos_drm_crtc_enable_vblank,
	.disable_vblank		= exynos_drm_crtc_disable_vblank,
	.gem_init_object	= exynos_drm_gem_init_object,
	.gem_free_object	= exynos_drm_gem_free_object,
	.gem_vm_ops		= &exynos_drm_gem_vm_ops,
	.dumb_create		= exynos_drm_gem_dumb_create,
	.dumb_map_offset	= exynos_drm_gem_dumb_map_offset,
	.dumb_destroy		= exynos_drm_gem_dumb_destroy,
	.prime_handle_to_fd	= drm_gem_prime_handle_to_fd,
	.prime_fd_to_handle	= drm_gem_prime_fd_to_handle,
	.gem_prime_export	= exynos_dmabuf_prime_export,
	.gem_prime_import	= exynos_dmabuf_prime_import,
	.ioctls			= exynos_ioctls,
	.fops			= &exynos_drm_driver_fops,
	.name	= DRIVER_NAME,
	.desc	= DRIVER_DESC,
	.date	= DRIVER_DATE,
	.major	= DRIVER_MAJOR,
	.minor	= DRIVER_MINOR,
};

static int exynos_drm_platform_probe(struct platform_device *pdev)
{
	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
	exynos_drm_driver.num_ioctls = DRM_ARRAY_SIZE(exynos_ioctls);

	return drm_platform_init(&exynos_drm_driver, pdev);
}

static int exynos_drm_platform_remove(struct platform_device *pdev)
{
	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	drm_platform_exit(&exynos_drm_driver, pdev);

	return 0;
}

static struct platform_driver exynos_drm_platform_driver = {
	.probe		= exynos_drm_platform_probe,
	.remove		= exynos_drm_platform_remove,
	.driver		= {
		.owner	= THIS_MODULE,
		.name	= "exynos-drm",
	},
};

static int __init exynos_drm_init(void)
{
	int ret;

	DRM_DEBUG_DRIVER("%s\n", __FILE__);

#ifdef CONFIG_DRM_EXYNOS_FIMD
	ret = platform_driver_register(&fimd_driver);
	if (ret < 0)
		goto out_fimd;
#endif

#ifdef CONFIG_DRM_EXYNOS_HDMI
	ret = platform_driver_register(&hdmi_driver);
	if (ret < 0)
		goto out_hdmi;
	ret = platform_driver_register(&mixer_driver);
	if (ret < 0)
		goto out_mixer;
	ret = platform_driver_register(&exynos_drm_common_hdmi_driver);
	if (ret < 0)
		goto out_common_hdmi;

	ret = exynos_platform_device_hdmi_register();
	if (ret < 0)
		goto out_common_hdmi_dev;
#endif

#ifdef CONFIG_DRM_EXYNOS_VIDI
	ret = platform_driver_register(&vidi_driver);
	if (ret < 0)
		goto out_vidi;
#endif

#ifdef CONFIG_DRM_EXYNOS_G2D
	ret = platform_driver_register(&g2d_driver);
	if (ret < 0)
		goto out_g2d;
#endif

#ifdef CONFIG_DRM_EXYNOS_FIMC
	ret = platform_driver_register(&fimc_driver);
	if (ret < 0)
		goto out_fimc;
#endif

#ifdef CONFIG_DRM_EXYNOS_ROTATOR
	ret = platform_driver_register(&rotator_driver);
	if (ret < 0)
		goto out_rotator;
#endif

#ifdef CONFIG_DRM_EXYNOS_GSC
	ret = platform_driver_register(&gsc_driver);
	if (ret < 0)
		goto out_gsc;
#endif

#ifdef CONFIG_DRM_EXYNOS_IPP
	ret = platform_driver_register(&ipp_driver);
	if (ret < 0)
		goto out_ipp;

	ret = exynos_platform_device_ipp_register();
	if (ret < 0)
		goto out_ipp_dev;
#endif

	ret = platform_driver_register(&exynos_drm_platform_driver);
	if (ret < 0)
		goto out_drm;

	exynos_drm_pdev = platform_device_register_simple("exynos-drm", -1,
				NULL, 0);
	if (IS_ERR(exynos_drm_pdev)) {
		ret = PTR_ERR(exynos_drm_pdev);
		goto out;
	}

	return 0;

out:
	platform_driver_unregister(&exynos_drm_platform_driver);

out_drm:
#ifdef CONFIG_DRM_EXYNOS_IPP
	exynos_platform_device_ipp_unregister();
out_ipp_dev:
	platform_driver_unregister(&ipp_driver);
out_ipp:
#endif

#ifdef CONFIG_DRM_EXYNOS_GSC
	platform_driver_unregister(&gsc_driver);
out_gsc:
#endif

#ifdef CONFIG_DRM_EXYNOS_ROTATOR
	platform_driver_unregister(&rotator_driver);
out_rotator:
#endif

#ifdef CONFIG_DRM_EXYNOS_FIMC
	platform_driver_unregister(&fimc_driver);
out_fimc:
#endif

#ifdef CONFIG_DRM_EXYNOS_G2D
	platform_driver_unregister(&g2d_driver);
out_g2d:
#endif

#ifdef CONFIG_DRM_EXYNOS_VIDI
	platform_driver_unregister(&vidi_driver);
out_vidi:
#endif

#ifdef CONFIG_DRM_EXYNOS_HDMI
	exynos_platform_device_hdmi_unregister();
out_common_hdmi_dev:
	platform_driver_unregister(&exynos_drm_common_hdmi_driver);
out_common_hdmi:
	platform_driver_unregister(&mixer_driver);
out_mixer:
	platform_driver_unregister(&hdmi_driver);
out_hdmi:
#endif

#ifdef CONFIG_DRM_EXYNOS_FIMD
	platform_driver_unregister(&fimd_driver);
out_fimd:
#endif
	return ret;
}

static void __exit exynos_drm_exit(void)
{
	DRM_DEBUG_DRIVER("%s\n", __FILE__);

	platform_device_unregister(exynos_drm_pdev);

	platform_driver_unregister(&exynos_drm_platform_driver);

#ifdef CONFIG_DRM_EXYNOS_IPP
	exynos_platform_device_ipp_unregister();
	platform_driver_unregister(&ipp_driver);
#endif

#ifdef CONFIG_DRM_EXYNOS_GSC
	platform_driver_unregister(&gsc_driver);
#endif

#ifdef CONFIG_DRM_EXYNOS_ROTATOR
	platform_driver_unregister(&rotator_driver);
#endif

#ifdef CONFIG_DRM_EXYNOS_FIMC
	platform_driver_unregister(&fimc_driver);
#endif

#ifdef CONFIG_DRM_EXYNOS_G2D
	platform_driver_unregister(&g2d_driver);
#endif

#ifdef CONFIG_DRM_EXYNOS_HDMI
	exynos_platform_device_hdmi_unregister();
	platform_driver_unregister(&exynos_drm_common_hdmi_driver);
	platform_driver_unregister(&mixer_driver);
	platform_driver_unregister(&hdmi_driver);
#endif

#ifdef CONFIG_DRM_EXYNOS_VIDI
	platform_driver_unregister(&vidi_driver);
#endif

#ifdef CONFIG_DRM_EXYNOS_FIMD
	platform_driver_unregister(&fimd_driver);
#endif
}

module_init(exynos_drm_init);
module_exit(exynos_drm_exit);

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