2 * Copyright (C) 2015 Etnaviv Project
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 as published by
6 * the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program. If not, see <http://www.gnu.org/licenses/>.
17 #include <linux/component.h>
18 #include <linux/of_platform.h>
20 #include "etnaviv_drv.h"
21 #include "etnaviv_gpu.h"
22 #include "etnaviv_gem.h"
23 #include "etnaviv_mmu.h"
24 #include "etnaviv_gem.h"
26 #ifdef CONFIG_DRM_ETNAVIV_REGISTER_LOGGING
28 MODULE_PARM_DESC(reglog
, "Enable register read/write logging");
29 module_param(reglog
, bool, 0600);
34 void __iomem
*etnaviv_ioremap(struct platform_device
*pdev
, const char *name
,
41 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, name
);
43 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
45 ptr
= devm_ioremap_resource(&pdev
->dev
, res
);
47 dev_err(&pdev
->dev
, "failed to ioremap %s: %ld\n", name
,
53 dev_printk(KERN_DEBUG
, &pdev
->dev
, "IO:region %s 0x%p %08zx\n",
54 dbgname
, ptr
, (size_t)resource_size(res
));
59 void etnaviv_writel(u32 data
, void __iomem
*addr
)
62 printk(KERN_DEBUG
"IO:W %p %08x\n", addr
, data
);
67 u32
etnaviv_readl(const void __iomem
*addr
)
69 u32 val
= readl(addr
);
72 printk(KERN_DEBUG
"IO:R %p %08x\n", addr
, val
);
82 static void load_gpu(struct drm_device
*dev
)
84 struct etnaviv_drm_private
*priv
= dev
->dev_private
;
87 for (i
= 0; i
< ETNA_MAX_PIPES
; i
++) {
88 struct etnaviv_gpu
*g
= priv
->gpu
[i
];
93 ret
= etnaviv_gpu_init(g
);
95 dev_err(g
->dev
, "hw init failed: %d\n", ret
);
102 static int etnaviv_open(struct drm_device
*dev
, struct drm_file
*file
)
104 struct etnaviv_file_private
*ctx
;
106 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
110 file
->driver_priv
= ctx
;
115 static void etnaviv_preclose(struct drm_device
*dev
, struct drm_file
*file
)
117 struct etnaviv_drm_private
*priv
= dev
->dev_private
;
118 struct etnaviv_file_private
*ctx
= file
->driver_priv
;
121 for (i
= 0; i
< ETNA_MAX_PIPES
; i
++) {
122 struct etnaviv_gpu
*gpu
= priv
->gpu
[i
];
125 mutex_lock(&gpu
->lock
);
126 if (gpu
->lastctx
== ctx
)
128 mutex_unlock(&gpu
->lock
);
139 #ifdef CONFIG_DEBUG_FS
140 static int etnaviv_gem_show(struct drm_device
*dev
, struct seq_file
*m
)
142 struct etnaviv_drm_private
*priv
= dev
->dev_private
;
144 etnaviv_gem_describe_objects(priv
, m
);
149 static int etnaviv_mm_show(struct drm_device
*dev
, struct seq_file
*m
)
153 read_lock(&dev
->vma_offset_manager
->vm_lock
);
154 ret
= drm_mm_dump_table(m
, &dev
->vma_offset_manager
->vm_addr_space_mm
);
155 read_unlock(&dev
->vma_offset_manager
->vm_lock
);
160 static int etnaviv_mmu_show(struct etnaviv_gpu
*gpu
, struct seq_file
*m
)
162 seq_printf(m
, "Active Objects (%s):\n", dev_name(gpu
->dev
));
164 mutex_lock(&gpu
->mmu
->lock
);
165 drm_mm_dump_table(m
, &gpu
->mmu
->mm
);
166 mutex_unlock(&gpu
->mmu
->lock
);
171 static void etnaviv_buffer_dump(struct etnaviv_gpu
*gpu
, struct seq_file
*m
)
173 struct etnaviv_cmdbuf
*buf
= gpu
->buffer
;
174 u32 size
= buf
->size
;
175 u32
*ptr
= buf
->vaddr
;
178 seq_printf(m
, "virt %p - phys 0x%llx - free 0x%08x\n",
179 buf
->vaddr
, (u64
)buf
->paddr
, size
- buf
->user_size
);
181 for (i
= 0; i
< size
/ 4; i
++) {
185 seq_printf(m
, "\t0x%p: ", ptr
+ i
);
186 seq_printf(m
, "%08x ", *(ptr
+ i
));
191 static int etnaviv_ring_show(struct etnaviv_gpu
*gpu
, struct seq_file
*m
)
193 seq_printf(m
, "Ring Buffer (%s): ", dev_name(gpu
->dev
));
195 mutex_lock(&gpu
->lock
);
196 etnaviv_buffer_dump(gpu
, m
);
197 mutex_unlock(&gpu
->lock
);
202 static int show_unlocked(struct seq_file
*m
, void *arg
)
204 struct drm_info_node
*node
= (struct drm_info_node
*) m
->private;
205 struct drm_device
*dev
= node
->minor
->dev
;
206 int (*show
)(struct drm_device
*dev
, struct seq_file
*m
) =
207 node
->info_ent
->data
;
212 static int show_each_gpu(struct seq_file
*m
, void *arg
)
214 struct drm_info_node
*node
= (struct drm_info_node
*) m
->private;
215 struct drm_device
*dev
= node
->minor
->dev
;
216 struct etnaviv_drm_private
*priv
= dev
->dev_private
;
217 struct etnaviv_gpu
*gpu
;
218 int (*show
)(struct etnaviv_gpu
*gpu
, struct seq_file
*m
) =
219 node
->info_ent
->data
;
223 for (i
= 0; i
< ETNA_MAX_PIPES
; i
++) {
236 static struct drm_info_list etnaviv_debugfs_list
[] = {
237 {"gpu", show_each_gpu
, 0, etnaviv_gpu_debugfs
},
238 {"gem", show_unlocked
, 0, etnaviv_gem_show
},
239 { "mm", show_unlocked
, 0, etnaviv_mm_show
},
240 {"mmu", show_each_gpu
, 0, etnaviv_mmu_show
},
241 {"ring", show_each_gpu
, 0, etnaviv_ring_show
},
244 static int etnaviv_debugfs_init(struct drm_minor
*minor
)
246 struct drm_device
*dev
= minor
->dev
;
249 ret
= drm_debugfs_create_files(etnaviv_debugfs_list
,
250 ARRAY_SIZE(etnaviv_debugfs_list
),
251 minor
->debugfs_root
, minor
);
254 dev_err(dev
->dev
, "could not install etnaviv_debugfs_list\n");
261 static void etnaviv_debugfs_cleanup(struct drm_minor
*minor
)
263 drm_debugfs_remove_files(etnaviv_debugfs_list
,
264 ARRAY_SIZE(etnaviv_debugfs_list
), minor
);
272 static int etnaviv_ioctl_get_param(struct drm_device
*dev
, void *data
,
273 struct drm_file
*file
)
275 struct etnaviv_drm_private
*priv
= dev
->dev_private
;
276 struct drm_etnaviv_param
*args
= data
;
277 struct etnaviv_gpu
*gpu
;
279 if (args
->pipe
>= ETNA_MAX_PIPES
)
282 gpu
= priv
->gpu
[args
->pipe
];
286 return etnaviv_gpu_get_param(gpu
, args
->param
, &args
->value
);
289 static int etnaviv_ioctl_gem_new(struct drm_device
*dev
, void *data
,
290 struct drm_file
*file
)
292 struct drm_etnaviv_gem_new
*args
= data
;
294 if (args
->flags
& ~(ETNA_BO_CACHED
| ETNA_BO_WC
| ETNA_BO_UNCACHED
|
298 return etnaviv_gem_new_handle(dev
, file
, args
->size
,
299 args
->flags
, &args
->handle
);
302 #define TS(t) ((struct timespec){ \
303 .tv_sec = (t).tv_sec, \
304 .tv_nsec = (t).tv_nsec \
307 static int etnaviv_ioctl_gem_cpu_prep(struct drm_device
*dev
, void *data
,
308 struct drm_file
*file
)
310 struct drm_etnaviv_gem_cpu_prep
*args
= data
;
311 struct drm_gem_object
*obj
;
314 if (args
->op
& ~(ETNA_PREP_READ
| ETNA_PREP_WRITE
| ETNA_PREP_NOSYNC
))
317 obj
= drm_gem_object_lookup(file
, args
->handle
);
321 ret
= etnaviv_gem_cpu_prep(obj
, args
->op
, &TS(args
->timeout
));
323 drm_gem_object_unreference_unlocked(obj
);
328 static int etnaviv_ioctl_gem_cpu_fini(struct drm_device
*dev
, void *data
,
329 struct drm_file
*file
)
331 struct drm_etnaviv_gem_cpu_fini
*args
= data
;
332 struct drm_gem_object
*obj
;
338 obj
= drm_gem_object_lookup(file
, args
->handle
);
342 ret
= etnaviv_gem_cpu_fini(obj
);
344 drm_gem_object_unreference_unlocked(obj
);
349 static int etnaviv_ioctl_gem_info(struct drm_device
*dev
, void *data
,
350 struct drm_file
*file
)
352 struct drm_etnaviv_gem_info
*args
= data
;
353 struct drm_gem_object
*obj
;
359 obj
= drm_gem_object_lookup(file
, args
->handle
);
363 ret
= etnaviv_gem_mmap_offset(obj
, &args
->offset
);
364 drm_gem_object_unreference_unlocked(obj
);
369 static int etnaviv_ioctl_wait_fence(struct drm_device
*dev
, void *data
,
370 struct drm_file
*file
)
372 struct drm_etnaviv_wait_fence
*args
= data
;
373 struct etnaviv_drm_private
*priv
= dev
->dev_private
;
374 struct timespec
*timeout
= &TS(args
->timeout
);
375 struct etnaviv_gpu
*gpu
;
377 if (args
->flags
& ~(ETNA_WAIT_NONBLOCK
))
380 if (args
->pipe
>= ETNA_MAX_PIPES
)
383 gpu
= priv
->gpu
[args
->pipe
];
387 if (args
->flags
& ETNA_WAIT_NONBLOCK
)
390 return etnaviv_gpu_wait_fence_interruptible(gpu
, args
->fence
,
394 static int etnaviv_ioctl_gem_userptr(struct drm_device
*dev
, void *data
,
395 struct drm_file
*file
)
397 struct drm_etnaviv_gem_userptr
*args
= data
;
400 if (args
->flags
& ~(ETNA_USERPTR_READ
|ETNA_USERPTR_WRITE
) ||
404 if (offset_in_page(args
->user_ptr
| args
->user_size
) ||
405 (uintptr_t)args
->user_ptr
!= args
->user_ptr
||
406 (u32
)args
->user_size
!= args
->user_size
||
407 args
->user_ptr
& ~PAGE_MASK
)
410 if (args
->flags
& ETNA_USERPTR_WRITE
)
411 access
= VERIFY_WRITE
;
413 access
= VERIFY_READ
;
415 if (!access_ok(access
, (void __user
*)(unsigned long)args
->user_ptr
,
419 return etnaviv_gem_new_userptr(dev
, file
, args
->user_ptr
,
420 args
->user_size
, args
->flags
,
424 static int etnaviv_ioctl_gem_wait(struct drm_device
*dev
, void *data
,
425 struct drm_file
*file
)
427 struct etnaviv_drm_private
*priv
= dev
->dev_private
;
428 struct drm_etnaviv_gem_wait
*args
= data
;
429 struct timespec
*timeout
= &TS(args
->timeout
);
430 struct drm_gem_object
*obj
;
431 struct etnaviv_gpu
*gpu
;
434 if (args
->flags
& ~(ETNA_WAIT_NONBLOCK
))
437 if (args
->pipe
>= ETNA_MAX_PIPES
)
440 gpu
= priv
->gpu
[args
->pipe
];
444 obj
= drm_gem_object_lookup(file
, args
->handle
);
448 if (args
->flags
& ETNA_WAIT_NONBLOCK
)
451 ret
= etnaviv_gem_wait_bo(gpu
, obj
, timeout
);
453 drm_gem_object_unreference_unlocked(obj
);
458 static const struct drm_ioctl_desc etnaviv_ioctls
[] = {
459 #define ETNA_IOCTL(n, func, flags) \
460 DRM_IOCTL_DEF_DRV(ETNAVIV_##n, etnaviv_ioctl_##func, flags)
461 ETNA_IOCTL(GET_PARAM
, get_param
, DRM_AUTH
|DRM_RENDER_ALLOW
),
462 ETNA_IOCTL(GEM_NEW
, gem_new
, DRM_AUTH
|DRM_RENDER_ALLOW
),
463 ETNA_IOCTL(GEM_INFO
, gem_info
, DRM_AUTH
|DRM_RENDER_ALLOW
),
464 ETNA_IOCTL(GEM_CPU_PREP
, gem_cpu_prep
, DRM_AUTH
|DRM_RENDER_ALLOW
),
465 ETNA_IOCTL(GEM_CPU_FINI
, gem_cpu_fini
, DRM_AUTH
|DRM_RENDER_ALLOW
),
466 ETNA_IOCTL(GEM_SUBMIT
, gem_submit
, DRM_AUTH
|DRM_RENDER_ALLOW
),
467 ETNA_IOCTL(WAIT_FENCE
, wait_fence
, DRM_AUTH
|DRM_RENDER_ALLOW
),
468 ETNA_IOCTL(GEM_USERPTR
, gem_userptr
, DRM_AUTH
|DRM_RENDER_ALLOW
),
469 ETNA_IOCTL(GEM_WAIT
, gem_wait
, DRM_AUTH
|DRM_RENDER_ALLOW
),
472 static const struct vm_operations_struct vm_ops
= {
473 .fault
= etnaviv_gem_fault
,
474 .open
= drm_gem_vm_open
,
475 .close
= drm_gem_vm_close
,
478 static const struct file_operations fops
= {
479 .owner
= THIS_MODULE
,
481 .release
= drm_release
,
482 .unlocked_ioctl
= drm_ioctl
,
484 .compat_ioctl
= drm_compat_ioctl
,
489 .mmap
= etnaviv_gem_mmap
,
492 static struct drm_driver etnaviv_drm_driver
= {
493 .driver_features
= DRIVER_HAVE_IRQ
|
497 .open
= etnaviv_open
,
498 .preclose
= etnaviv_preclose
,
499 .set_busid
= drm_platform_set_busid
,
500 .gem_free_object_unlocked
= etnaviv_gem_free_object
,
501 .gem_vm_ops
= &vm_ops
,
502 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
503 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
504 .gem_prime_export
= drm_gem_prime_export
,
505 .gem_prime_import
= drm_gem_prime_import
,
506 .gem_prime_pin
= etnaviv_gem_prime_pin
,
507 .gem_prime_unpin
= etnaviv_gem_prime_unpin
,
508 .gem_prime_get_sg_table
= etnaviv_gem_prime_get_sg_table
,
509 .gem_prime_import_sg_table
= etnaviv_gem_prime_import_sg_table
,
510 .gem_prime_vmap
= etnaviv_gem_prime_vmap
,
511 .gem_prime_vunmap
= etnaviv_gem_prime_vunmap
,
512 #ifdef CONFIG_DEBUG_FS
513 .debugfs_init
= etnaviv_debugfs_init
,
514 .debugfs_cleanup
= etnaviv_debugfs_cleanup
,
516 .ioctls
= etnaviv_ioctls
,
517 .num_ioctls
= DRM_ETNAVIV_NUM_IOCTLS
,
520 .desc
= "etnaviv DRM",
529 static int etnaviv_bind(struct device
*dev
)
531 struct etnaviv_drm_private
*priv
;
532 struct drm_device
*drm
;
535 drm
= drm_dev_alloc(&etnaviv_drm_driver
, dev
);
539 drm
->platformdev
= to_platform_device(dev
);
541 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
543 dev_err(dev
, "failed to allocate private data\n");
547 drm
->dev_private
= priv
;
549 priv
->wq
= alloc_ordered_workqueue("etnaviv", 0);
555 mutex_init(&priv
->gem_lock
);
556 INIT_LIST_HEAD(&priv
->gem_list
);
559 dev_set_drvdata(dev
, drm
);
561 ret
= component_bind_all(dev
, drm
);
567 ret
= drm_dev_register(drm
, 0);
574 component_unbind_all(dev
, drm
);
576 flush_workqueue(priv
->wq
);
577 destroy_workqueue(priv
->wq
);
586 static void etnaviv_unbind(struct device
*dev
)
588 struct drm_device
*drm
= dev_get_drvdata(dev
);
589 struct etnaviv_drm_private
*priv
= drm
->dev_private
;
591 drm_dev_unregister(drm
);
593 flush_workqueue(priv
->wq
);
594 destroy_workqueue(priv
->wq
);
596 component_unbind_all(dev
, drm
);
598 drm
->dev_private
= NULL
;
604 static const struct component_master_ops etnaviv_master_ops
= {
605 .bind
= etnaviv_bind
,
606 .unbind
= etnaviv_unbind
,
609 static int compare_of(struct device
*dev
, void *data
)
611 struct device_node
*np
= data
;
613 return dev
->of_node
== np
;
616 static int compare_str(struct device
*dev
, void *data
)
618 return !strcmp(dev_name(dev
), data
);
621 static int etnaviv_pdev_probe(struct platform_device
*pdev
)
623 struct device
*dev
= &pdev
->dev
;
624 struct device_node
*node
= dev
->of_node
;
625 struct component_match
*match
= NULL
;
627 dma_set_coherent_mask(&pdev
->dev
, DMA_BIT_MASK(32));
630 struct device_node
*core_node
;
634 core_node
= of_parse_phandle(node
, "cores", i
);
638 component_match_add(&pdev
->dev
, &match
, compare_of
,
640 of_node_put(core_node
);
642 } else if (dev
->platform_data
) {
643 char **names
= dev
->platform_data
;
646 for (i
= 0; names
[i
]; i
++)
647 component_match_add(dev
, &match
, compare_str
, names
[i
]);
650 return component_master_add_with_match(dev
, &etnaviv_master_ops
, match
);
653 static int etnaviv_pdev_remove(struct platform_device
*pdev
)
655 component_master_del(&pdev
->dev
, &etnaviv_master_ops
);
660 static const struct of_device_id dt_match
[] = {
661 { .compatible
= "fsl,imx-gpu-subsystem" },
662 { .compatible
= "marvell,dove-gpu-subsystem" },
665 MODULE_DEVICE_TABLE(of
, dt_match
);
667 static struct platform_driver etnaviv_platform_driver
= {
668 .probe
= etnaviv_pdev_probe
,
669 .remove
= etnaviv_pdev_remove
,
672 .of_match_table
= dt_match
,
676 static int __init
etnaviv_init(void)
680 etnaviv_validate_init();
682 ret
= platform_driver_register(&etnaviv_gpu_driver
);
686 ret
= platform_driver_register(&etnaviv_platform_driver
);
688 platform_driver_unregister(&etnaviv_gpu_driver
);
692 module_init(etnaviv_init
);
694 static void __exit
etnaviv_exit(void)
696 platform_driver_unregister(&etnaviv_gpu_driver
);
697 platform_driver_unregister(&etnaviv_platform_driver
);
699 module_exit(etnaviv_exit
);
701 MODULE_AUTHOR("Christian Gmeiner <christian.gmeiner@gmail.com>");
702 MODULE_AUTHOR("Russell King <rmk+kernel@arm.linux.org.uk>");
703 MODULE_AUTHOR("Lucas Stach <l.stach@pengutronix.de>");
704 MODULE_DESCRIPTION("etnaviv DRM Driver");
705 MODULE_LICENSE("GPL v2");
706 MODULE_ALIAS("platform:etnaviv");