2 * Copyright (C) 2013 Red Hat
3 * Author: Rob Clark <robdclark@gmail.com>
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program. If not, see <http://www.gnu.org/licenses/>.
22 static void msm_fb_output_poll_changed(struct drm_device *dev)
24 struct msm_drm_private *priv = dev->dev_private;
26 drm_fb_helper_hotplug_event(priv->fbdev);
29 static const struct drm_mode_config_funcs mode_config_funcs = {
30 .fb_create = msm_framebuffer_create,
31 .output_poll_changed = msm_fb_output_poll_changed,
32 .atomic_check = msm_atomic_check,
33 .atomic_commit = msm_atomic_commit,
36 int msm_register_mmu(struct drm_device *dev, struct msm_mmu *mmu)
38 struct msm_drm_private *priv = dev->dev_private;
39 int idx = priv->num_mmus++;
41 if (WARN_ON(idx >= ARRAY_SIZE(priv->mmus)))
44 priv->mmus[idx] = mmu;
49 #ifdef CONFIG_DRM_MSM_REGISTER_LOGGING
50 static bool reglog = false;
51 MODULE_PARM_DESC(reglog, "Enable register read/write logging");
52 module_param(reglog, bool, 0600);
57 #ifdef CONFIG_DRM_FBDEV_EMULATION
58 static bool fbdev = true;
59 MODULE_PARM_DESC(fbdev, "Enable fbdev compat layer");
60 module_param(fbdev, bool, 0600);
63 static char *vram = "16m";
64 MODULE_PARM_DESC(vram, "Configure VRAM size (for devices without IOMMU/GPUMMU");
65 module_param(vram, charp, 0);
71 void __iomem *msm_ioremap(struct platform_device *pdev, const char *name,
79 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
81 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
84 dev_err(&pdev->dev, "failed to get memory resource: %s\n", name);
85 return ERR_PTR(-EINVAL);
88 size = resource_size(res);
90 ptr = devm_ioremap_nocache(&pdev->dev, res->start, size);
92 dev_err(&pdev->dev, "failed to ioremap: %s\n", name);
93 return ERR_PTR(-ENOMEM);
97 printk(KERN_DEBUG "IO:region %s %p %08lx\n", dbgname, ptr, size);
102 void msm_writel(u32 data, void __iomem *addr)
105 printk(KERN_DEBUG "IO:W %p %08x\n", addr, data);
109 u32 msm_readl(const void __iomem *addr)
111 u32 val = readl(addr);
113 printk(KERN_ERR "IO:R %p %08x\n", addr, val);
117 struct vblank_event {
118 struct list_head node;
123 static void vblank_ctrl_worker(struct work_struct *work)
125 struct msm_vblank_ctrl *vbl_ctrl = container_of(work,
126 struct msm_vblank_ctrl, work);
127 struct msm_drm_private *priv = container_of(vbl_ctrl,
128 struct msm_drm_private, vblank_ctrl);
129 struct msm_kms *kms = priv->kms;
130 struct vblank_event *vbl_ev, *tmp;
133 spin_lock_irqsave(&vbl_ctrl->lock, flags);
134 list_for_each_entry_safe(vbl_ev, tmp, &vbl_ctrl->event_list, node) {
135 list_del(&vbl_ev->node);
136 spin_unlock_irqrestore(&vbl_ctrl->lock, flags);
139 kms->funcs->enable_vblank(kms,
140 priv->crtcs[vbl_ev->crtc_id]);
142 kms->funcs->disable_vblank(kms,
143 priv->crtcs[vbl_ev->crtc_id]);
147 spin_lock_irqsave(&vbl_ctrl->lock, flags);
150 spin_unlock_irqrestore(&vbl_ctrl->lock, flags);
153 static int vblank_ctrl_queue_work(struct msm_drm_private *priv,
154 int crtc_id, bool enable)
156 struct msm_vblank_ctrl *vbl_ctrl = &priv->vblank_ctrl;
157 struct vblank_event *vbl_ev;
160 vbl_ev = kzalloc(sizeof(*vbl_ev), GFP_ATOMIC);
164 vbl_ev->crtc_id = crtc_id;
165 vbl_ev->enable = enable;
167 spin_lock_irqsave(&vbl_ctrl->lock, flags);
168 list_add_tail(&vbl_ev->node, &vbl_ctrl->event_list);
169 spin_unlock_irqrestore(&vbl_ctrl->lock, flags);
171 queue_work(priv->wq, &vbl_ctrl->work);
180 static int msm_unload(struct drm_device *dev)
182 struct msm_drm_private *priv = dev->dev_private;
183 struct msm_kms *kms = priv->kms;
184 struct msm_gpu *gpu = priv->gpu;
185 struct msm_vblank_ctrl *vbl_ctrl = &priv->vblank_ctrl;
186 struct vblank_event *vbl_ev, *tmp;
188 /* We must cancel and cleanup any pending vblank enable/disable
189 * work before drm_irq_uninstall() to avoid work re-enabling an
190 * irq after uninstall has disabled it.
192 cancel_work_sync(&vbl_ctrl->work);
193 list_for_each_entry_safe(vbl_ev, tmp, &vbl_ctrl->event_list, node) {
194 list_del(&vbl_ev->node);
198 drm_kms_helper_poll_fini(dev);
199 drm_mode_config_cleanup(dev);
200 drm_vblank_cleanup(dev);
202 pm_runtime_get_sync(dev->dev);
203 drm_irq_uninstall(dev);
204 pm_runtime_put_sync(dev->dev);
206 flush_workqueue(priv->wq);
207 destroy_workqueue(priv->wq);
210 pm_runtime_disable(dev->dev);
211 kms->funcs->destroy(kms);
215 mutex_lock(&dev->struct_mutex);
216 gpu->funcs->pm_suspend(gpu);
217 mutex_unlock(&dev->struct_mutex);
218 gpu->funcs->destroy(gpu);
221 if (priv->vram.paddr) {
222 DEFINE_DMA_ATTRS(attrs);
223 dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &attrs);
224 drm_mm_takedown(&priv->vram.mm);
225 dma_free_attrs(dev->dev, priv->vram.size, NULL,
226 priv->vram.paddr, &attrs);
229 component_unbind_all(dev->dev, dev);
231 dev->dev_private = NULL;
238 static int get_mdp_ver(struct platform_device *pdev)
240 struct device *dev = &pdev->dev;
242 return (int) (unsigned long) of_device_get_match_data(dev);
245 #include <linux/of_address.h>
247 static int msm_init_vram(struct drm_device *dev)
249 struct msm_drm_private *priv = dev->dev_private;
250 struct device_node *node;
251 unsigned long size = 0;
254 /* In the device-tree world, we could have a 'memory-region'
255 * phandle, which gives us a link to our "vram". Allocating
256 * is all nicely abstracted behind the dma api, but we need
257 * to know the entire size to allocate it all in one go. There
259 * 1) device with no IOMMU, in which case we need exclusive
260 * access to a VRAM carveout big enough for all gpu
262 * 2) device with IOMMU, but where the bootloader puts up
263 * a splash screen. In this case, the VRAM carveout
264 * need only be large enough for fbdev fb. But we need
265 * exclusive access to the buffer to avoid the kernel
266 * using those pages for other purposes (which appears
267 * as corruption on screen before we have a chance to
268 * load and do initial modeset)
271 node = of_parse_phandle(dev->dev->of_node, "memory-region", 0);
274 ret = of_address_to_resource(node, 0, &r);
277 size = r.end - r.start;
278 DRM_INFO("using VRAM carveout: %lx@%pa\n", size, &r.start);
280 /* if we have no IOMMU, then we need to use carveout allocator.
281 * Grab the entire CMA chunk carved out in early startup in
284 } else if (!iommu_present(&platform_bus_type)) {
285 DRM_INFO("using %s VRAM carveout\n", vram);
286 size = memparse(vram, NULL);
290 DEFINE_DMA_ATTRS(attrs);
293 priv->vram.size = size;
295 drm_mm_init(&priv->vram.mm, 0, (size >> PAGE_SHIFT) - 1);
297 dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &attrs);
298 dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
300 /* note that for no-kernel-mapping, the vaddr returned
301 * is bogus, but non-null if allocation succeeded:
303 p = dma_alloc_attrs(dev->dev, size,
304 &priv->vram.paddr, GFP_KERNEL, &attrs);
306 dev_err(dev->dev, "failed to allocate VRAM\n");
307 priv->vram.paddr = 0;
311 dev_info(dev->dev, "VRAM: %08x->%08x\n",
312 (uint32_t)priv->vram.paddr,
313 (uint32_t)(priv->vram.paddr + size));
319 static int msm_load(struct drm_device *dev, unsigned long flags)
321 struct platform_device *pdev = dev->platformdev;
322 struct msm_drm_private *priv;
326 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
328 dev_err(dev->dev, "failed to allocate private data\n");
332 dev->dev_private = priv;
334 priv->wq = alloc_ordered_workqueue("msm", 0);
335 init_waitqueue_head(&priv->fence_event);
336 init_waitqueue_head(&priv->pending_crtcs_event);
338 INIT_LIST_HEAD(&priv->inactive_list);
339 INIT_LIST_HEAD(&priv->fence_cbs);
340 INIT_LIST_HEAD(&priv->vblank_ctrl.event_list);
341 INIT_WORK(&priv->vblank_ctrl.work, vblank_ctrl_worker);
342 spin_lock_init(&priv->vblank_ctrl.lock);
344 drm_mode_config_init(dev);
346 platform_set_drvdata(pdev, dev);
348 /* Bind all our sub-components: */
349 ret = component_bind_all(dev->dev, dev);
353 ret = msm_init_vram(dev);
357 switch (get_mdp_ver(pdev)) {
359 kms = mdp4_kms_init(dev);
362 kms = mdp5_kms_init(dev);
365 kms = ERR_PTR(-ENODEV);
371 * NOTE: once we have GPU support, having no kms should not
372 * be considered fatal.. ideally we would still support gpu
373 * and (for example) use dmabuf/prime to share buffers with
374 * imx drm driver on iMX5
376 dev_err(dev->dev, "failed to load kms\n");
384 pm_runtime_enable(dev->dev);
385 ret = kms->funcs->hw_init(kms);
387 dev_err(dev->dev, "kms hw init failed: %d\n", ret);
392 dev->mode_config.funcs = &mode_config_funcs;
394 ret = drm_vblank_init(dev, priv->num_crtcs);
396 dev_err(dev->dev, "failed to initialize vblank\n");
400 pm_runtime_get_sync(dev->dev);
401 ret = drm_irq_install(dev, platform_get_irq(dev->platformdev, 0));
402 pm_runtime_put_sync(dev->dev);
404 dev_err(dev->dev, "failed to install IRQ handler\n");
408 drm_mode_config_reset(dev);
410 #ifdef CONFIG_DRM_FBDEV_EMULATION
412 priv->fbdev = msm_fbdev_init(dev);
415 ret = msm_debugfs_late_init(dev);
419 drm_kms_helper_poll_init(dev);
428 static void load_gpu(struct drm_device *dev)
430 static DEFINE_MUTEX(init_lock);
431 struct msm_drm_private *priv = dev->dev_private;
433 mutex_lock(&init_lock);
436 priv->gpu = adreno_load_gpu(dev);
438 mutex_unlock(&init_lock);
441 static int msm_open(struct drm_device *dev, struct drm_file *file)
443 struct msm_file_private *ctx;
445 /* For now, load gpu on open.. to avoid the requirement of having
446 * firmware in the initrd.
450 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
454 file->driver_priv = ctx;
459 static void msm_preclose(struct drm_device *dev, struct drm_file *file)
461 struct msm_drm_private *priv = dev->dev_private;
462 struct msm_file_private *ctx = file->driver_priv;
463 struct msm_kms *kms = priv->kms;
466 kms->funcs->preclose(kms, file);
468 mutex_lock(&dev->struct_mutex);
469 if (ctx == priv->lastctx)
470 priv->lastctx = NULL;
471 mutex_unlock(&dev->struct_mutex);
476 static void msm_lastclose(struct drm_device *dev)
478 struct msm_drm_private *priv = dev->dev_private;
480 drm_fb_helper_restore_fbdev_mode_unlocked(priv->fbdev);
483 static irqreturn_t msm_irq(int irq, void *arg)
485 struct drm_device *dev = arg;
486 struct msm_drm_private *priv = dev->dev_private;
487 struct msm_kms *kms = priv->kms;
489 return kms->funcs->irq(kms);
492 static void msm_irq_preinstall(struct drm_device *dev)
494 struct msm_drm_private *priv = dev->dev_private;
495 struct msm_kms *kms = priv->kms;
497 kms->funcs->irq_preinstall(kms);
500 static int msm_irq_postinstall(struct drm_device *dev)
502 struct msm_drm_private *priv = dev->dev_private;
503 struct msm_kms *kms = priv->kms;
505 return kms->funcs->irq_postinstall(kms);
508 static void msm_irq_uninstall(struct drm_device *dev)
510 struct msm_drm_private *priv = dev->dev_private;
511 struct msm_kms *kms = priv->kms;
513 kms->funcs->irq_uninstall(kms);
516 static int msm_enable_vblank(struct drm_device *dev, unsigned int pipe)
518 struct msm_drm_private *priv = dev->dev_private;
519 struct msm_kms *kms = priv->kms;
522 DBG("dev=%p, crtc=%u", dev, pipe);
523 return vblank_ctrl_queue_work(priv, pipe, true);
526 static void msm_disable_vblank(struct drm_device *dev, unsigned int pipe)
528 struct msm_drm_private *priv = dev->dev_private;
529 struct msm_kms *kms = priv->kms;
532 DBG("dev=%p, crtc=%u", dev, pipe);
533 vblank_ctrl_queue_work(priv, pipe, false);
540 #ifdef CONFIG_DEBUG_FS
541 static int msm_gpu_show(struct drm_device *dev, struct seq_file *m)
543 struct msm_drm_private *priv = dev->dev_private;
544 struct msm_gpu *gpu = priv->gpu;
547 seq_printf(m, "%s Status:\n", gpu->name);
548 gpu->funcs->show(gpu, m);
554 static int msm_gem_show(struct drm_device *dev, struct seq_file *m)
556 struct msm_drm_private *priv = dev->dev_private;
557 struct msm_gpu *gpu = priv->gpu;
560 seq_printf(m, "Active Objects (%s):\n", gpu->name);
561 msm_gem_describe_objects(&gpu->active_list, m);
564 seq_printf(m, "Inactive Objects:\n");
565 msm_gem_describe_objects(&priv->inactive_list, m);
570 static int msm_mm_show(struct drm_device *dev, struct seq_file *m)
572 return drm_mm_dump_table(m, &dev->vma_offset_manager->vm_addr_space_mm);
575 static int msm_fb_show(struct drm_device *dev, struct seq_file *m)
577 struct msm_drm_private *priv = dev->dev_private;
578 struct drm_framebuffer *fb, *fbdev_fb = NULL;
581 seq_printf(m, "fbcon ");
582 fbdev_fb = priv->fbdev->fb;
583 msm_framebuffer_describe(fbdev_fb, m);
586 mutex_lock(&dev->mode_config.fb_lock);
587 list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
591 seq_printf(m, "user ");
592 msm_framebuffer_describe(fb, m);
594 mutex_unlock(&dev->mode_config.fb_lock);
599 static int show_locked(struct seq_file *m, void *arg)
601 struct drm_info_node *node = (struct drm_info_node *) m->private;
602 struct drm_device *dev = node->minor->dev;
603 int (*show)(struct drm_device *dev, struct seq_file *m) =
604 node->info_ent->data;
607 ret = mutex_lock_interruptible(&dev->struct_mutex);
613 mutex_unlock(&dev->struct_mutex);
618 static struct drm_info_list msm_debugfs_list[] = {
619 {"gpu", show_locked, 0, msm_gpu_show},
620 {"gem", show_locked, 0, msm_gem_show},
621 { "mm", show_locked, 0, msm_mm_show },
622 { "fb", show_locked, 0, msm_fb_show },
625 static int late_init_minor(struct drm_minor *minor)
632 ret = msm_rd_debugfs_init(minor);
634 dev_err(minor->dev->dev, "could not install rd debugfs\n");
638 ret = msm_perf_debugfs_init(minor);
640 dev_err(minor->dev->dev, "could not install perf debugfs\n");
647 int msm_debugfs_late_init(struct drm_device *dev)
650 ret = late_init_minor(dev->primary);
653 ret = late_init_minor(dev->render);
656 ret = late_init_minor(dev->control);
660 static int msm_debugfs_init(struct drm_minor *minor)
662 struct drm_device *dev = minor->dev;
665 ret = drm_debugfs_create_files(msm_debugfs_list,
666 ARRAY_SIZE(msm_debugfs_list),
667 minor->debugfs_root, minor);
670 dev_err(dev->dev, "could not install msm_debugfs_list\n");
677 static void msm_debugfs_cleanup(struct drm_minor *minor)
679 drm_debugfs_remove_files(msm_debugfs_list,
680 ARRAY_SIZE(msm_debugfs_list), minor);
681 if (!minor->dev->dev_private)
683 msm_rd_debugfs_cleanup(minor);
684 msm_perf_debugfs_cleanup(minor);
692 int msm_wait_fence(struct drm_device *dev, uint32_t fence,
693 ktime_t *timeout , bool interruptible)
695 struct msm_drm_private *priv = dev->dev_private;
701 if (fence > priv->gpu->submitted_fence) {
702 DRM_ERROR("waiting on invalid fence: %u (of %u)\n",
703 fence, priv->gpu->submitted_fence);
709 ret = fence_completed(dev, fence) ? 0 : -EBUSY;
711 ktime_t now = ktime_get();
712 unsigned long remaining_jiffies;
714 if (ktime_compare(*timeout, now) < 0) {
715 remaining_jiffies = 0;
717 ktime_t rem = ktime_sub(*timeout, now);
718 struct timespec ts = ktime_to_timespec(rem);
719 remaining_jiffies = timespec_to_jiffies(&ts);
723 ret = wait_event_interruptible_timeout(priv->fence_event,
724 fence_completed(dev, fence),
727 ret = wait_event_timeout(priv->fence_event,
728 fence_completed(dev, fence),
732 DBG("timeout waiting for fence: %u (completed: %u)",
733 fence, priv->completed_fence);
735 } else if (ret != -ERESTARTSYS) {
743 int msm_queue_fence_cb(struct drm_device *dev,
744 struct msm_fence_cb *cb, uint32_t fence)
746 struct msm_drm_private *priv = dev->dev_private;
749 mutex_lock(&dev->struct_mutex);
750 if (!list_empty(&cb->work.entry)) {
752 } else if (fence > priv->completed_fence) {
754 list_add_tail(&cb->work.entry, &priv->fence_cbs);
756 queue_work(priv->wq, &cb->work);
758 mutex_unlock(&dev->struct_mutex);
763 /* called from workqueue */
764 void msm_update_fence(struct drm_device *dev, uint32_t fence)
766 struct msm_drm_private *priv = dev->dev_private;
768 mutex_lock(&dev->struct_mutex);
769 priv->completed_fence = max(fence, priv->completed_fence);
771 while (!list_empty(&priv->fence_cbs)) {
772 struct msm_fence_cb *cb;
774 cb = list_first_entry(&priv->fence_cbs,
775 struct msm_fence_cb, work.entry);
777 if (cb->fence > priv->completed_fence)
780 list_del_init(&cb->work.entry);
781 queue_work(priv->wq, &cb->work);
784 mutex_unlock(&dev->struct_mutex);
786 wake_up_all(&priv->fence_event);
789 void __msm_fence_worker(struct work_struct *work)
791 struct msm_fence_cb *cb = container_of(work, struct msm_fence_cb, work);
799 static int msm_ioctl_get_param(struct drm_device *dev, void *data,
800 struct drm_file *file)
802 struct msm_drm_private *priv = dev->dev_private;
803 struct drm_msm_param *args = data;
806 /* for now, we just have 3d pipe.. eventually this would need to
807 * be more clever to dispatch to appropriate gpu module:
809 if (args->pipe != MSM_PIPE_3D0)
817 return gpu->funcs->get_param(gpu, args->param, &args->value);
820 static int msm_ioctl_gem_new(struct drm_device *dev, void *data,
821 struct drm_file *file)
823 struct drm_msm_gem_new *args = data;
825 if (args->flags & ~MSM_BO_FLAGS) {
826 DRM_ERROR("invalid flags: %08x\n", args->flags);
830 return msm_gem_new_handle(dev, file, args->size,
831 args->flags, &args->handle);
834 static inline ktime_t to_ktime(struct drm_msm_timespec timeout)
836 return ktime_set(timeout.tv_sec, timeout.tv_nsec);
839 static int msm_ioctl_gem_cpu_prep(struct drm_device *dev, void *data,
840 struct drm_file *file)
842 struct drm_msm_gem_cpu_prep *args = data;
843 struct drm_gem_object *obj;
844 ktime_t timeout = to_ktime(args->timeout);
847 if (args->op & ~MSM_PREP_FLAGS) {
848 DRM_ERROR("invalid op: %08x\n", args->op);
852 obj = drm_gem_object_lookup(dev, file, args->handle);
856 ret = msm_gem_cpu_prep(obj, args->op, &timeout);
858 drm_gem_object_unreference_unlocked(obj);
863 static int msm_ioctl_gem_cpu_fini(struct drm_device *dev, void *data,
864 struct drm_file *file)
866 struct drm_msm_gem_cpu_fini *args = data;
867 struct drm_gem_object *obj;
870 obj = drm_gem_object_lookup(dev, file, args->handle);
874 ret = msm_gem_cpu_fini(obj);
876 drm_gem_object_unreference_unlocked(obj);
881 static int msm_ioctl_gem_info(struct drm_device *dev, void *data,
882 struct drm_file *file)
884 struct drm_msm_gem_info *args = data;
885 struct drm_gem_object *obj;
891 obj = drm_gem_object_lookup(dev, file, args->handle);
895 args->offset = msm_gem_mmap_offset(obj);
897 drm_gem_object_unreference_unlocked(obj);
902 static int msm_ioctl_wait_fence(struct drm_device *dev, void *data,
903 struct drm_file *file)
905 struct drm_msm_wait_fence *args = data;
906 ktime_t timeout = to_ktime(args->timeout);
909 DRM_ERROR("invalid pad: %08x\n", args->pad);
913 return msm_wait_fence(dev, args->fence, &timeout, true);
916 static const struct drm_ioctl_desc msm_ioctls[] = {
917 DRM_IOCTL_DEF_DRV(MSM_GET_PARAM, msm_ioctl_get_param, DRM_AUTH|DRM_RENDER_ALLOW),
918 DRM_IOCTL_DEF_DRV(MSM_GEM_NEW, msm_ioctl_gem_new, DRM_AUTH|DRM_RENDER_ALLOW),
919 DRM_IOCTL_DEF_DRV(MSM_GEM_INFO, msm_ioctl_gem_info, DRM_AUTH|DRM_RENDER_ALLOW),
920 DRM_IOCTL_DEF_DRV(MSM_GEM_CPU_PREP, msm_ioctl_gem_cpu_prep, DRM_AUTH|DRM_RENDER_ALLOW),
921 DRM_IOCTL_DEF_DRV(MSM_GEM_CPU_FINI, msm_ioctl_gem_cpu_fini, DRM_AUTH|DRM_RENDER_ALLOW),
922 DRM_IOCTL_DEF_DRV(MSM_GEM_SUBMIT, msm_ioctl_gem_submit, DRM_AUTH|DRM_RENDER_ALLOW),
923 DRM_IOCTL_DEF_DRV(MSM_WAIT_FENCE, msm_ioctl_wait_fence, DRM_AUTH|DRM_RENDER_ALLOW),
926 static const struct vm_operations_struct vm_ops = {
927 .fault = msm_gem_fault,
928 .open = drm_gem_vm_open,
929 .close = drm_gem_vm_close,
932 static const struct file_operations fops = {
933 .owner = THIS_MODULE,
935 .release = drm_release,
936 .unlocked_ioctl = drm_ioctl,
938 .compat_ioctl = drm_compat_ioctl,
943 .mmap = msm_gem_mmap,
946 static struct drm_driver msm_driver = {
947 .driver_features = DRIVER_HAVE_IRQ |
954 .unload = msm_unload,
956 .preclose = msm_preclose,
957 .lastclose = msm_lastclose,
958 .set_busid = drm_platform_set_busid,
959 .irq_handler = msm_irq,
960 .irq_preinstall = msm_irq_preinstall,
961 .irq_postinstall = msm_irq_postinstall,
962 .irq_uninstall = msm_irq_uninstall,
963 .get_vblank_counter = drm_vblank_no_hw_counter,
964 .enable_vblank = msm_enable_vblank,
965 .disable_vblank = msm_disable_vblank,
966 .gem_free_object = msm_gem_free_object,
967 .gem_vm_ops = &vm_ops,
968 .dumb_create = msm_gem_dumb_create,
969 .dumb_map_offset = msm_gem_dumb_map_offset,
970 .dumb_destroy = drm_gem_dumb_destroy,
971 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
972 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
973 .gem_prime_export = drm_gem_prime_export,
974 .gem_prime_import = drm_gem_prime_import,
975 .gem_prime_pin = msm_gem_prime_pin,
976 .gem_prime_unpin = msm_gem_prime_unpin,
977 .gem_prime_get_sg_table = msm_gem_prime_get_sg_table,
978 .gem_prime_import_sg_table = msm_gem_prime_import_sg_table,
979 .gem_prime_vmap = msm_gem_prime_vmap,
980 .gem_prime_vunmap = msm_gem_prime_vunmap,
981 .gem_prime_mmap = msm_gem_prime_mmap,
982 #ifdef CONFIG_DEBUG_FS
983 .debugfs_init = msm_debugfs_init,
984 .debugfs_cleanup = msm_debugfs_cleanup,
986 .ioctls = msm_ioctls,
987 .num_ioctls = DRM_MSM_NUM_IOCTLS,
990 .desc = "MSM Snapdragon DRM",
996 #ifdef CONFIG_PM_SLEEP
997 static int msm_pm_suspend(struct device *dev)
999 struct drm_device *ddev = dev_get_drvdata(dev);
1001 drm_kms_helper_poll_disable(ddev);
1006 static int msm_pm_resume(struct device *dev)
1008 struct drm_device *ddev = dev_get_drvdata(dev);
1010 drm_kms_helper_poll_enable(ddev);
1016 static const struct dev_pm_ops msm_pm_ops = {
1017 SET_SYSTEM_SLEEP_PM_OPS(msm_pm_suspend, msm_pm_resume)
1021 * Componentized driver support:
1025 * NOTE: duplication of the same code as exynos or imx (or probably any other).
1026 * so probably some room for some helpers
1028 static int compare_of(struct device *dev, void *data)
1030 return dev->of_node == data;
1033 static int add_components(struct device *dev, struct component_match **matchptr,
1036 struct device_node *np = dev->of_node;
1039 for (i = 0; ; i++) {
1040 struct device_node *node;
1042 node = of_parse_phandle(np, name, i);
1046 component_match_add(dev, matchptr, compare_of, node);
1052 static int msm_drm_bind(struct device *dev)
1054 return drm_platform_init(&msm_driver, to_platform_device(dev));
1057 static void msm_drm_unbind(struct device *dev)
1059 drm_put_dev(platform_get_drvdata(to_platform_device(dev)));
1062 static const struct component_master_ops msm_drm_ops = {
1063 .bind = msm_drm_bind,
1064 .unbind = msm_drm_unbind,
1071 static int msm_pdev_probe(struct platform_device *pdev)
1073 struct component_match *match = NULL;
1075 add_components(&pdev->dev, &match, "connectors");
1076 add_components(&pdev->dev, &match, "gpus");
1078 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
1079 return component_master_add_with_match(&pdev->dev, &msm_drm_ops, match);
1082 static int msm_pdev_remove(struct platform_device *pdev)
1084 component_master_del(&pdev->dev, &msm_drm_ops);
1089 static const struct platform_device_id msm_id[] = {
1094 static const struct of_device_id dt_match[] = {
1095 { .compatible = "qcom,mdp4", .data = (void *) 4 }, /* mdp4 */
1096 { .compatible = "qcom,mdp5", .data = (void *) 5 }, /* mdp5 */
1097 /* to support downstream DT files */
1098 { .compatible = "qcom,mdss_mdp", .data = (void *) 5 }, /* mdp5 */
1101 MODULE_DEVICE_TABLE(of, dt_match);
1103 static struct platform_driver msm_platform_driver = {
1104 .probe = msm_pdev_probe,
1105 .remove = msm_pdev_remove,
1108 .of_match_table = dt_match,
1114 static int __init msm_drm_register(void)
1121 return platform_driver_register(&msm_platform_driver);
1124 static void __exit msm_drm_unregister(void)
1127 platform_driver_unregister(&msm_platform_driver);
1129 adreno_unregister();
1130 msm_edp_unregister();
1131 msm_dsi_unregister();
1134 module_init(msm_drm_register);
1135 module_exit(msm_drm_unregister);
1137 MODULE_AUTHOR("Rob Clark <robdclark@gmail.com");
1138 MODULE_DESCRIPTION("MSM DRM Driver");
1139 MODULE_LICENSE("GPL");