Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/gpu/drm/exynos/exynos_drm_drv.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us