exynos_drm_drv.c revision 3ab09435d5fbad63842cd2749f95deec336eb566 
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 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice (including the next
16 * paragraph) shall be included in all copies or substantial portions of the
17 * Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
22 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
23 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
24 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
25 * OTHER DEALINGS IN THE SOFTWARE.
26 */
27
28#include "drmP.h"
29#include "drm.h"
30#include "drm_crtc_helper.h"
31
32#include <drm/exynos_drm.h>
33
34#include "exynos_drm_drv.h"
35#include "exynos_drm_crtc.h"
36#include "exynos_drm_encoder.h"
37#include "exynos_drm_fbdev.h"
38#include "exynos_drm_fb.h"
39#include "exynos_drm_gem.h"
40#include "exynos_drm_plane.h"
41
42#define DRIVER_NAME	"exynos"
43#define DRIVER_DESC	"Samsung SoC DRM"
44#define DRIVER_DATE	"20110530"
45#define DRIVER_MAJOR	1
46#define DRIVER_MINOR	0
47
48#define VBLANK_OFF_DELAY	50000
49
50static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
51{
52	struct exynos_drm_private *private;
53	int ret;
54	int nr;
55
56	DRM_DEBUG_DRIVER("%s\n", __FILE__);
57
58	private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL);
59	if (!private) {
60		DRM_ERROR("failed to allocate private\n");
61		return -ENOMEM;
62	}
63
64	INIT_LIST_HEAD(&private->pageflip_event_list);
65	dev->dev_private = (void *)private;
66
67	drm_mode_config_init(dev);
68
69	/* init kms poll for handling hpd */
70	drm_kms_helper_poll_init(dev);
71
72	exynos_drm_mode_config_init(dev);
73
74	/*
75	 * EXYNOS4 is enough to have two CRTCs and each crtc would be used
76	 * without dependency of hardware.
77	 */
78	for (nr = 0; nr < MAX_CRTC; nr++) {
79		ret = exynos_drm_crtc_create(dev, nr);
80		if (ret)
81			goto err_crtc;
82	}
83
84	for (nr = 0; nr < MAX_PLANE; nr++) {
85		ret = exynos_plane_init(dev, nr);
86		if (ret)
87			goto err_crtc;
88	}
89
90	ret = drm_vblank_init(dev, MAX_CRTC);
91	if (ret)
92		goto err_crtc;
93
94	/*
95	 * probe sub drivers such as display controller and hdmi driver,
96	 * that were registered at probe() of platform driver
97	 * to the sub driver and create encoder and connector for them.
98	 */
99	ret = exynos_drm_device_register(dev);
100	if (ret)
101		goto err_vblank;
102
103	/* setup possible_clones. */
104	exynos_drm_encoder_setup(dev);
105
106	/*
107	 * create and configure fb helper and also exynos specific
108	 * fbdev object.
109	 */
110	ret = exynos_drm_fbdev_init(dev);
111	if (ret) {
112		DRM_ERROR("failed to initialize drm fbdev\n");
113		goto err_drm_device;
114	}
115
116	drm_vblank_offdelay = VBLANK_OFF_DELAY;
117
118	return 0;
119
120err_drm_device:
121	exynos_drm_device_unregister(dev);
122err_vblank:
123	drm_vblank_cleanup(dev);
124err_crtc:
125	drm_mode_config_cleanup(dev);
126	kfree(private);
127
128	return ret;
129}
130
131static int exynos_drm_unload(struct drm_device *dev)
132{
133	DRM_DEBUG_DRIVER("%s\n", __FILE__);
134
135	exynos_drm_fbdev_fini(dev);
136	exynos_drm_device_unregister(dev);
137	drm_vblank_cleanup(dev);
138	drm_kms_helper_poll_fini(dev);
139	drm_mode_config_cleanup(dev);
140	kfree(dev->dev_private);
141
142	dev->dev_private = NULL;
143
144	return 0;
145}
146
147static void exynos_drm_preclose(struct drm_device *dev,
148					struct drm_file *file)
149{
150	struct exynos_drm_private *private = dev->dev_private;
151	struct drm_pending_vblank_event *e, *t;
152	unsigned long flags;
153
154	DRM_DEBUG_DRIVER("%s\n", __FILE__);
155
156	/* release events of current file */
157	spin_lock_irqsave(&dev->event_lock, flags);
158	list_for_each_entry_safe(e, t, &private->pageflip_event_list,
159			base.link) {
160		if (e->base.file_priv == file) {
161			list_del(&e->base.link);
162			e->base.destroy(&e->base);
163		}
164	}
165	spin_unlock_irqrestore(&dev->event_lock, flags);
166}
167
168static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
169{
170	DRM_DEBUG_DRIVER("%s\n", __FILE__);
171
172	if (!file->driver_priv)
173		return;
174
175	kfree(file->driver_priv);
176	file->driver_priv = NULL;
177}
178
179static void exynos_drm_lastclose(struct drm_device *dev)
180{
181	DRM_DEBUG_DRIVER("%s\n", __FILE__);
182
183	exynos_drm_fbdev_restore_mode(dev);
184}
185
186static struct vm_operations_struct exynos_drm_gem_vm_ops = {
187	.fault = exynos_drm_gem_fault,
188	.open = drm_gem_vm_open,
189	.close = drm_gem_vm_close,
190};
191
192static struct drm_ioctl_desc exynos_ioctls[] = {
193	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl,
194			DRM_UNLOCKED | DRM_AUTH),
195	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MAP_OFFSET,
196			exynos_drm_gem_map_offset_ioctl, DRM_UNLOCKED |
197			DRM_AUTH),
198	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MMAP,
199			exynos_drm_gem_mmap_ioctl, DRM_UNLOCKED | DRM_AUTH),
200	DRM_IOCTL_DEF_DRV(EXYNOS_PLANE_SET_ZPOS, exynos_plane_set_zpos_ioctl,
201			DRM_UNLOCKED | DRM_AUTH),
202};
203
204static const struct file_operations exynos_drm_driver_fops = {
205	.owner		= THIS_MODULE,
206	.open		= drm_open,
207	.mmap		= exynos_drm_gem_mmap,
208	.poll		= drm_poll,
209	.read		= drm_read,
210	.unlocked_ioctl	= drm_ioctl,
211	.release	= drm_release,
212};
213
214static struct drm_driver exynos_drm_driver = {
215	.driver_features	= DRIVER_HAVE_IRQ | DRIVER_BUS_PLATFORM |
216				  DRIVER_MODESET | DRIVER_GEM,
217	.load			= exynos_drm_load,
218	.unload			= exynos_drm_unload,
219	.preclose		= exynos_drm_preclose,
220	.lastclose		= exynos_drm_lastclose,
221	.postclose		= exynos_drm_postclose,
222	.get_vblank_counter	= drm_vblank_count,
223	.enable_vblank		= exynos_drm_crtc_enable_vblank,
224	.disable_vblank		= exynos_drm_crtc_disable_vblank,
225	.gem_init_object	= exynos_drm_gem_init_object,
226	.gem_free_object	= exynos_drm_gem_free_object,
227	.gem_vm_ops		= &exynos_drm_gem_vm_ops,
228	.dumb_create		= exynos_drm_gem_dumb_create,
229	.dumb_map_offset	= exynos_drm_gem_dumb_map_offset,
230	.dumb_destroy		= exynos_drm_gem_dumb_destroy,
231	.ioctls			= exynos_ioctls,
232	.fops			= &exynos_drm_driver_fops,
233	.name	= DRIVER_NAME,
234	.desc	= DRIVER_DESC,
235	.date	= DRIVER_DATE,
236	.major	= DRIVER_MAJOR,
237	.minor	= DRIVER_MINOR,
238};
239
240static int exynos_drm_platform_probe(struct platform_device *pdev)
241{
242	DRM_DEBUG_DRIVER("%s\n", __FILE__);
243
244	exynos_drm_driver.num_ioctls = DRM_ARRAY_SIZE(exynos_ioctls);
245
246	return drm_platform_init(&exynos_drm_driver, pdev);
247}
248
249static int exynos_drm_platform_remove(struct platform_device *pdev)
250{
251	DRM_DEBUG_DRIVER("%s\n", __FILE__);
252
253	drm_platform_exit(&exynos_drm_driver, pdev);
254
255	return 0;
256}
257
258static struct platform_driver exynos_drm_platform_driver = {
259	.probe		= exynos_drm_platform_probe,
260	.remove		= __devexit_p(exynos_drm_platform_remove),
261	.driver		= {
262		.owner	= THIS_MODULE,
263		.name	= DRIVER_NAME,
264	},
265};
266
267static int __init exynos_drm_init(void)
268{
269	DRM_DEBUG_DRIVER("%s\n", __FILE__);
270
271	return platform_driver_register(&exynos_drm_platform_driver);
272}
273
274static void __exit exynos_drm_exit(void)
275{
276	DRM_DEBUG_DRIVER("%s\n", __FILE__);
277
278	platform_driver_unregister(&exynos_drm_platform_driver);
279}
280
281module_init(exynos_drm_init);
282module_exit(exynos_drm_exit);
283
284MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
285MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
286MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
287MODULE_DESCRIPTION("Samsung SoC DRM Driver");
288MODULE_LICENSE("GPL");
289