2 * Copyright (C) 2012 Avionic Design GmbH
3 * Copyright (C) 2012-2013 NVIDIA CORPORATION. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
10 #include <linux/host1x.h>
11 #include <linux/iommu.h>
16 #define DRIVER_NAME "tegra"
17 #define DRIVER_DESC "NVIDIA Tegra graphics"
18 #define DRIVER_DATE "20120330"
19 #define DRIVER_MAJOR 0
20 #define DRIVER_MINOR 0
21 #define DRIVER_PATCHLEVEL 0
23 struct tegra_drm_file
{
24 struct list_head contexts
;
27 static int tegra_drm_load(struct drm_device
*drm
, unsigned long flags
)
29 struct host1x_device
*device
= to_host1x_device(drm
->dev
);
30 struct tegra_drm
*tegra
;
33 tegra
= kzalloc(sizeof(*tegra
), GFP_KERNEL
);
37 if (iommu_present(&platform_bus_type
)) {
38 tegra
->domain
= iommu_domain_alloc(&platform_bus_type
);
39 if (IS_ERR(tegra
->domain
)) {
40 err
= PTR_ERR(tegra
->domain
);
44 DRM_DEBUG("IOMMU context initialized\n");
45 drm_mm_init(&tegra
->mm
, 0, SZ_2G
);
48 mutex_init(&tegra
->clients_lock
);
49 INIT_LIST_HEAD(&tegra
->clients
);
50 drm
->dev_private
= tegra
;
53 drm_mode_config_init(drm
);
55 err
= tegra_drm_fb_prepare(drm
);
59 drm_kms_helper_poll_init(drm
);
61 err
= host1x_device_init(device
);
66 * We don't use the drm_irq_install() helpers provided by the DRM
67 * core, so we need to set this manually in order to allow the
68 * DRM_IOCTL_WAIT_VBLANK to operate correctly.
70 drm
->irq_enabled
= true;
72 err
= drm_vblank_init(drm
, drm
->mode_config
.num_crtc
);
76 err
= tegra_drm_fb_init(drm
);
83 drm_vblank_cleanup(drm
);
85 host1x_device_exit(device
);
87 drm_kms_helper_poll_fini(drm
);
88 tegra_drm_fb_free(drm
);
90 drm_mode_config_cleanup(drm
);
93 iommu_domain_free(tegra
->domain
);
94 drm_mm_takedown(&tegra
->mm
);
101 static int tegra_drm_unload(struct drm_device
*drm
)
103 struct host1x_device
*device
= to_host1x_device(drm
->dev
);
104 struct tegra_drm
*tegra
= drm
->dev_private
;
107 drm_kms_helper_poll_fini(drm
);
108 tegra_drm_fb_exit(drm
);
109 drm_vblank_cleanup(drm
);
110 drm_mode_config_cleanup(drm
);
112 err
= host1x_device_exit(device
);
117 iommu_domain_free(tegra
->domain
);
118 drm_mm_takedown(&tegra
->mm
);
126 static int tegra_drm_open(struct drm_device
*drm
, struct drm_file
*filp
)
128 struct tegra_drm_file
*fpriv
;
130 fpriv
= kzalloc(sizeof(*fpriv
), GFP_KERNEL
);
134 INIT_LIST_HEAD(&fpriv
->contexts
);
135 filp
->driver_priv
= fpriv
;
140 static void tegra_drm_context_free(struct tegra_drm_context
*context
)
142 context
->client
->ops
->close_channel(context
);
146 static void tegra_drm_lastclose(struct drm_device
*drm
)
148 #ifdef CONFIG_DRM_TEGRA_FBDEV
149 struct tegra_drm
*tegra
= drm
->dev_private
;
151 tegra_fbdev_restore_mode(tegra
->fbdev
);
155 static struct host1x_bo
*
156 host1x_bo_lookup(struct drm_device
*drm
, struct drm_file
*file
, u32 handle
)
158 struct drm_gem_object
*gem
;
161 gem
= drm_gem_object_lookup(drm
, file
, handle
);
165 mutex_lock(&drm
->struct_mutex
);
166 drm_gem_object_unreference(gem
);
167 mutex_unlock(&drm
->struct_mutex
);
169 bo
= to_tegra_bo(gem
);
173 static int host1x_reloc_copy_from_user(struct host1x_reloc
*dest
,
174 struct drm_tegra_reloc __user
*src
,
175 struct drm_device
*drm
,
176 struct drm_file
*file
)
181 err
= get_user(cmdbuf
, &src
->cmdbuf
.handle
);
185 err
= get_user(dest
->cmdbuf
.offset
, &src
->cmdbuf
.offset
);
189 err
= get_user(target
, &src
->target
.handle
);
193 err
= get_user(dest
->target
.offset
, &src
->cmdbuf
.offset
);
197 err
= get_user(dest
->shift
, &src
->shift
);
201 dest
->cmdbuf
.bo
= host1x_bo_lookup(drm
, file
, cmdbuf
);
202 if (!dest
->cmdbuf
.bo
)
205 dest
->target
.bo
= host1x_bo_lookup(drm
, file
, target
);
206 if (!dest
->target
.bo
)
212 int tegra_drm_submit(struct tegra_drm_context
*context
,
213 struct drm_tegra_submit
*args
, struct drm_device
*drm
,
214 struct drm_file
*file
)
216 unsigned int num_cmdbufs
= args
->num_cmdbufs
;
217 unsigned int num_relocs
= args
->num_relocs
;
218 unsigned int num_waitchks
= args
->num_waitchks
;
219 struct drm_tegra_cmdbuf __user
*cmdbufs
=
220 (void __user
*)(uintptr_t)args
->cmdbufs
;
221 struct drm_tegra_reloc __user
*relocs
=
222 (void __user
*)(uintptr_t)args
->relocs
;
223 struct drm_tegra_waitchk __user
*waitchks
=
224 (void __user
*)(uintptr_t)args
->waitchks
;
225 struct drm_tegra_syncpt syncpt
;
226 struct host1x_job
*job
;
229 /* We don't yet support other than one syncpt_incr struct per submit */
230 if (args
->num_syncpts
!= 1)
233 job
= host1x_job_alloc(context
->channel
, args
->num_cmdbufs
,
234 args
->num_relocs
, args
->num_waitchks
);
238 job
->num_relocs
= args
->num_relocs
;
239 job
->num_waitchk
= args
->num_waitchks
;
240 job
->client
= (u32
)args
->context
;
241 job
->class = context
->client
->base
.class;
242 job
->serialize
= true;
244 while (num_cmdbufs
) {
245 struct drm_tegra_cmdbuf cmdbuf
;
246 struct host1x_bo
*bo
;
248 if (copy_from_user(&cmdbuf
, cmdbufs
, sizeof(cmdbuf
))) {
253 bo
= host1x_bo_lookup(drm
, file
, cmdbuf
.handle
);
259 host1x_job_add_gather(job
, bo
, cmdbuf
.words
, cmdbuf
.offset
);
264 /* copy and resolve relocations from submit */
265 while (num_relocs
--) {
266 err
= host1x_reloc_copy_from_user(&job
->relocarray
[num_relocs
],
267 &relocs
[num_relocs
], drm
,
273 if (copy_from_user(job
->waitchk
, waitchks
,
274 sizeof(*waitchks
) * num_waitchks
)) {
279 if (copy_from_user(&syncpt
, (void __user
*)(uintptr_t)args
->syncpts
,
285 job
->is_addr_reg
= context
->client
->ops
->is_addr_reg
;
286 job
->syncpt_incrs
= syncpt
.incrs
;
287 job
->syncpt_id
= syncpt
.id
;
288 job
->timeout
= 10000;
290 if (args
->timeout
&& args
->timeout
< 10000)
291 job
->timeout
= args
->timeout
;
293 err
= host1x_job_pin(job
, context
->client
->base
.dev
);
297 err
= host1x_job_submit(job
);
301 args
->fence
= job
->syncpt_end
;
307 host1x_job_unpin(job
);
314 #ifdef CONFIG_DRM_TEGRA_STAGING
315 static struct tegra_drm_context
*tegra_drm_get_context(__u64 context
)
317 return (struct tegra_drm_context
*)(uintptr_t)context
;
320 static bool tegra_drm_file_owns_context(struct tegra_drm_file
*file
,
321 struct tegra_drm_context
*context
)
323 struct tegra_drm_context
*ctx
;
325 list_for_each_entry(ctx
, &file
->contexts
, list
)
332 static int tegra_gem_create(struct drm_device
*drm
, void *data
,
333 struct drm_file
*file
)
335 struct drm_tegra_gem_create
*args
= data
;
338 bo
= tegra_bo_create_with_handle(file
, drm
, args
->size
, args
->flags
,
346 static int tegra_gem_mmap(struct drm_device
*drm
, void *data
,
347 struct drm_file
*file
)
349 struct drm_tegra_gem_mmap
*args
= data
;
350 struct drm_gem_object
*gem
;
353 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
357 bo
= to_tegra_bo(gem
);
359 args
->offset
= drm_vma_node_offset_addr(&bo
->gem
.vma_node
);
361 drm_gem_object_unreference(gem
);
366 static int tegra_syncpt_read(struct drm_device
*drm
, void *data
,
367 struct drm_file
*file
)
369 struct host1x
*host
= dev_get_drvdata(drm
->dev
->parent
);
370 struct drm_tegra_syncpt_read
*args
= data
;
371 struct host1x_syncpt
*sp
;
373 sp
= host1x_syncpt_get(host
, args
->id
);
377 args
->value
= host1x_syncpt_read_min(sp
);
381 static int tegra_syncpt_incr(struct drm_device
*drm
, void *data
,
382 struct drm_file
*file
)
384 struct host1x
*host1x
= dev_get_drvdata(drm
->dev
->parent
);
385 struct drm_tegra_syncpt_incr
*args
= data
;
386 struct host1x_syncpt
*sp
;
388 sp
= host1x_syncpt_get(host1x
, args
->id
);
392 return host1x_syncpt_incr(sp
);
395 static int tegra_syncpt_wait(struct drm_device
*drm
, void *data
,
396 struct drm_file
*file
)
398 struct host1x
*host1x
= dev_get_drvdata(drm
->dev
->parent
);
399 struct drm_tegra_syncpt_wait
*args
= data
;
400 struct host1x_syncpt
*sp
;
402 sp
= host1x_syncpt_get(host1x
, args
->id
);
406 return host1x_syncpt_wait(sp
, args
->thresh
, args
->timeout
,
410 static int tegra_open_channel(struct drm_device
*drm
, void *data
,
411 struct drm_file
*file
)
413 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
414 struct tegra_drm
*tegra
= drm
->dev_private
;
415 struct drm_tegra_open_channel
*args
= data
;
416 struct tegra_drm_context
*context
;
417 struct tegra_drm_client
*client
;
420 context
= kzalloc(sizeof(*context
), GFP_KERNEL
);
424 list_for_each_entry(client
, &tegra
->clients
, list
)
425 if (client
->base
.class == args
->client
) {
426 err
= client
->ops
->open_channel(client
, context
);
430 list_add(&context
->list
, &fpriv
->contexts
);
431 args
->context
= (uintptr_t)context
;
432 context
->client
= client
;
440 static int tegra_close_channel(struct drm_device
*drm
, void *data
,
441 struct drm_file
*file
)
443 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
444 struct drm_tegra_close_channel
*args
= data
;
445 struct tegra_drm_context
*context
;
447 context
= tegra_drm_get_context(args
->context
);
449 if (!tegra_drm_file_owns_context(fpriv
, context
))
452 list_del(&context
->list
);
453 tegra_drm_context_free(context
);
458 static int tegra_get_syncpt(struct drm_device
*drm
, void *data
,
459 struct drm_file
*file
)
461 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
462 struct drm_tegra_get_syncpt
*args
= data
;
463 struct tegra_drm_context
*context
;
464 struct host1x_syncpt
*syncpt
;
466 context
= tegra_drm_get_context(args
->context
);
468 if (!tegra_drm_file_owns_context(fpriv
, context
))
471 if (args
->index
>= context
->client
->base
.num_syncpts
)
474 syncpt
= context
->client
->base
.syncpts
[args
->index
];
475 args
->id
= host1x_syncpt_id(syncpt
);
480 static int tegra_submit(struct drm_device
*drm
, void *data
,
481 struct drm_file
*file
)
483 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
484 struct drm_tegra_submit
*args
= data
;
485 struct tegra_drm_context
*context
;
487 context
= tegra_drm_get_context(args
->context
);
489 if (!tegra_drm_file_owns_context(fpriv
, context
))
492 return context
->client
->ops
->submit(context
, args
, drm
, file
);
495 static int tegra_get_syncpt_base(struct drm_device
*drm
, void *data
,
496 struct drm_file
*file
)
498 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
499 struct drm_tegra_get_syncpt_base
*args
= data
;
500 struct tegra_drm_context
*context
;
501 struct host1x_syncpt_base
*base
;
502 struct host1x_syncpt
*syncpt
;
504 context
= tegra_drm_get_context(args
->context
);
506 if (!tegra_drm_file_owns_context(fpriv
, context
))
509 if (args
->syncpt
>= context
->client
->base
.num_syncpts
)
512 syncpt
= context
->client
->base
.syncpts
[args
->syncpt
];
514 base
= host1x_syncpt_get_base(syncpt
);
518 args
->id
= host1x_syncpt_base_id(base
);
523 static int tegra_gem_set_tiling(struct drm_device
*drm
, void *data
,
524 struct drm_file
*file
)
526 struct drm_tegra_gem_set_tiling
*args
= data
;
527 enum tegra_bo_tiling_mode mode
;
528 struct drm_gem_object
*gem
;
529 unsigned long value
= 0;
532 switch (args
->mode
) {
533 case DRM_TEGRA_GEM_TILING_MODE_PITCH
:
534 mode
= TEGRA_BO_TILING_MODE_PITCH
;
536 if (args
->value
!= 0)
541 case DRM_TEGRA_GEM_TILING_MODE_TILED
:
542 mode
= TEGRA_BO_TILING_MODE_TILED
;
544 if (args
->value
!= 0)
549 case DRM_TEGRA_GEM_TILING_MODE_BLOCK
:
550 mode
= TEGRA_BO_TILING_MODE_BLOCK
;
562 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
566 bo
= to_tegra_bo(gem
);
568 bo
->tiling
.mode
= mode
;
569 bo
->tiling
.value
= value
;
571 drm_gem_object_unreference(gem
);
576 static int tegra_gem_get_tiling(struct drm_device
*drm
, void *data
,
577 struct drm_file
*file
)
579 struct drm_tegra_gem_get_tiling
*args
= data
;
580 struct drm_gem_object
*gem
;
584 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
588 bo
= to_tegra_bo(gem
);
590 switch (bo
->tiling
.mode
) {
591 case TEGRA_BO_TILING_MODE_PITCH
:
592 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_PITCH
;
596 case TEGRA_BO_TILING_MODE_TILED
:
597 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_TILED
;
601 case TEGRA_BO_TILING_MODE_BLOCK
:
602 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_BLOCK
;
603 args
->value
= bo
->tiling
.value
;
611 drm_gem_object_unreference(gem
);
616 static int tegra_gem_set_flags(struct drm_device
*drm
, void *data
,
617 struct drm_file
*file
)
619 struct drm_tegra_gem_set_flags
*args
= data
;
620 struct drm_gem_object
*gem
;
623 if (args
->flags
& ~DRM_TEGRA_GEM_FLAGS
)
626 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
630 bo
= to_tegra_bo(gem
);
633 if (args
->flags
& DRM_TEGRA_GEM_BOTTOM_UP
)
634 bo
->flags
|= TEGRA_BO_BOTTOM_UP
;
636 drm_gem_object_unreference(gem
);
641 static int tegra_gem_get_flags(struct drm_device
*drm
, void *data
,
642 struct drm_file
*file
)
644 struct drm_tegra_gem_get_flags
*args
= data
;
645 struct drm_gem_object
*gem
;
648 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
652 bo
= to_tegra_bo(gem
);
655 if (bo
->flags
& TEGRA_BO_BOTTOM_UP
)
656 args
->flags
|= DRM_TEGRA_GEM_BOTTOM_UP
;
658 drm_gem_object_unreference(gem
);
664 static const struct drm_ioctl_desc tegra_drm_ioctls
[] = {
665 #ifdef CONFIG_DRM_TEGRA_STAGING
666 DRM_IOCTL_DEF_DRV(TEGRA_GEM_CREATE
, tegra_gem_create
, DRM_UNLOCKED
),
667 DRM_IOCTL_DEF_DRV(TEGRA_GEM_MMAP
, tegra_gem_mmap
, DRM_UNLOCKED
),
668 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_READ
, tegra_syncpt_read
, DRM_UNLOCKED
),
669 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_INCR
, tegra_syncpt_incr
, DRM_UNLOCKED
),
670 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_WAIT
, tegra_syncpt_wait
, DRM_UNLOCKED
),
671 DRM_IOCTL_DEF_DRV(TEGRA_OPEN_CHANNEL
, tegra_open_channel
, DRM_UNLOCKED
),
672 DRM_IOCTL_DEF_DRV(TEGRA_CLOSE_CHANNEL
, tegra_close_channel
, DRM_UNLOCKED
),
673 DRM_IOCTL_DEF_DRV(TEGRA_GET_SYNCPT
, tegra_get_syncpt
, DRM_UNLOCKED
),
674 DRM_IOCTL_DEF_DRV(TEGRA_SUBMIT
, tegra_submit
, DRM_UNLOCKED
),
675 DRM_IOCTL_DEF_DRV(TEGRA_GET_SYNCPT_BASE
, tegra_get_syncpt_base
, DRM_UNLOCKED
),
676 DRM_IOCTL_DEF_DRV(TEGRA_GEM_SET_TILING
, tegra_gem_set_tiling
, DRM_UNLOCKED
),
677 DRM_IOCTL_DEF_DRV(TEGRA_GEM_GET_TILING
, tegra_gem_get_tiling
, DRM_UNLOCKED
),
678 DRM_IOCTL_DEF_DRV(TEGRA_GEM_SET_FLAGS
, tegra_gem_set_flags
, DRM_UNLOCKED
),
679 DRM_IOCTL_DEF_DRV(TEGRA_GEM_GET_FLAGS
, tegra_gem_get_flags
, DRM_UNLOCKED
),
683 static const struct file_operations tegra_drm_fops
= {
684 .owner
= THIS_MODULE
,
686 .release
= drm_release
,
687 .unlocked_ioctl
= drm_ioctl
,
688 .mmap
= tegra_drm_mmap
,
692 .compat_ioctl
= drm_compat_ioctl
,
694 .llseek
= noop_llseek
,
697 static struct drm_crtc
*tegra_crtc_from_pipe(struct drm_device
*drm
, int pipe
)
699 struct drm_crtc
*crtc
;
701 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
) {
702 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
704 if (dc
->pipe
== pipe
)
711 static u32
tegra_drm_get_vblank_counter(struct drm_device
*dev
, int crtc
)
713 /* TODO: implement real hardware counter using syncpoints */
714 return drm_vblank_count(dev
, crtc
);
717 static int tegra_drm_enable_vblank(struct drm_device
*drm
, int pipe
)
719 struct drm_crtc
*crtc
= tegra_crtc_from_pipe(drm
, pipe
);
720 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
725 tegra_dc_enable_vblank(dc
);
730 static void tegra_drm_disable_vblank(struct drm_device
*drm
, int pipe
)
732 struct drm_crtc
*crtc
= tegra_crtc_from_pipe(drm
, pipe
);
733 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
736 tegra_dc_disable_vblank(dc
);
739 static void tegra_drm_preclose(struct drm_device
*drm
, struct drm_file
*file
)
741 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
742 struct tegra_drm_context
*context
, *tmp
;
743 struct drm_crtc
*crtc
;
745 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
)
746 tegra_dc_cancel_page_flip(crtc
, file
);
748 list_for_each_entry_safe(context
, tmp
, &fpriv
->contexts
, list
)
749 tegra_drm_context_free(context
);
754 #ifdef CONFIG_DEBUG_FS
755 static int tegra_debugfs_framebuffers(struct seq_file
*s
, void *data
)
757 struct drm_info_node
*node
= (struct drm_info_node
*)s
->private;
758 struct drm_device
*drm
= node
->minor
->dev
;
759 struct drm_framebuffer
*fb
;
761 mutex_lock(&drm
->mode_config
.fb_lock
);
763 list_for_each_entry(fb
, &drm
->mode_config
.fb_list
, head
) {
764 seq_printf(s
, "%3d: user size: %d x %d, depth %d, %d bpp, refcount %d\n",
765 fb
->base
.id
, fb
->width
, fb
->height
, fb
->depth
,
767 atomic_read(&fb
->refcount
.refcount
));
770 mutex_unlock(&drm
->mode_config
.fb_lock
);
775 static struct drm_info_list tegra_debugfs_list
[] = {
776 { "framebuffers", tegra_debugfs_framebuffers
, 0 },
779 static int tegra_debugfs_init(struct drm_minor
*minor
)
781 return drm_debugfs_create_files(tegra_debugfs_list
,
782 ARRAY_SIZE(tegra_debugfs_list
),
783 minor
->debugfs_root
, minor
);
786 static void tegra_debugfs_cleanup(struct drm_minor
*minor
)
788 drm_debugfs_remove_files(tegra_debugfs_list
,
789 ARRAY_SIZE(tegra_debugfs_list
), minor
);
793 static struct drm_driver tegra_drm_driver
= {
794 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
| DRIVER_PRIME
,
795 .load
= tegra_drm_load
,
796 .unload
= tegra_drm_unload
,
797 .open
= tegra_drm_open
,
798 .preclose
= tegra_drm_preclose
,
799 .lastclose
= tegra_drm_lastclose
,
801 .get_vblank_counter
= tegra_drm_get_vblank_counter
,
802 .enable_vblank
= tegra_drm_enable_vblank
,
803 .disable_vblank
= tegra_drm_disable_vblank
,
805 #if defined(CONFIG_DEBUG_FS)
806 .debugfs_init
= tegra_debugfs_init
,
807 .debugfs_cleanup
= tegra_debugfs_cleanup
,
810 .gem_free_object
= tegra_bo_free_object
,
811 .gem_vm_ops
= &tegra_bo_vm_ops
,
813 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
814 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
815 .gem_prime_export
= tegra_gem_prime_export
,
816 .gem_prime_import
= tegra_gem_prime_import
,
818 .dumb_create
= tegra_bo_dumb_create
,
819 .dumb_map_offset
= tegra_bo_dumb_map_offset
,
820 .dumb_destroy
= drm_gem_dumb_destroy
,
822 .ioctls
= tegra_drm_ioctls
,
823 .num_ioctls
= ARRAY_SIZE(tegra_drm_ioctls
),
824 .fops
= &tegra_drm_fops
,
829 .major
= DRIVER_MAJOR
,
830 .minor
= DRIVER_MINOR
,
831 .patchlevel
= DRIVER_PATCHLEVEL
,
834 int tegra_drm_register_client(struct tegra_drm
*tegra
,
835 struct tegra_drm_client
*client
)
837 mutex_lock(&tegra
->clients_lock
);
838 list_add_tail(&client
->list
, &tegra
->clients
);
839 mutex_unlock(&tegra
->clients_lock
);
844 int tegra_drm_unregister_client(struct tegra_drm
*tegra
,
845 struct tegra_drm_client
*client
)
847 mutex_lock(&tegra
->clients_lock
);
848 list_del_init(&client
->list
);
849 mutex_unlock(&tegra
->clients_lock
);
854 static int host1x_drm_probe(struct host1x_device
*dev
)
856 struct drm_driver
*driver
= &tegra_drm_driver
;
857 struct drm_device
*drm
;
860 drm
= drm_dev_alloc(driver
, &dev
->dev
);
864 drm_dev_set_unique(drm
, dev_name(&dev
->dev
));
865 dev_set_drvdata(&dev
->dev
, drm
);
867 err
= drm_dev_register(drm
, 0);
871 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", driver
->name
,
872 driver
->major
, driver
->minor
, driver
->patchlevel
,
873 driver
->date
, drm
->primary
->index
);
882 static int host1x_drm_remove(struct host1x_device
*dev
)
884 struct drm_device
*drm
= dev_get_drvdata(&dev
->dev
);
886 drm_dev_unregister(drm
);
892 static const struct of_device_id host1x_drm_subdevs
[] = {
893 { .compatible
= "nvidia,tegra20-dc", },
894 { .compatible
= "nvidia,tegra20-hdmi", },
895 { .compatible
= "nvidia,tegra20-gr2d", },
896 { .compatible
= "nvidia,tegra20-gr3d", },
897 { .compatible
= "nvidia,tegra30-dc", },
898 { .compatible
= "nvidia,tegra30-hdmi", },
899 { .compatible
= "nvidia,tegra30-gr2d", },
900 { .compatible
= "nvidia,tegra30-gr3d", },
901 { .compatible
= "nvidia,tegra114-dsi", },
902 { .compatible
= "nvidia,tegra114-hdmi", },
903 { .compatible
= "nvidia,tegra114-gr3d", },
904 { .compatible
= "nvidia,tegra124-dc", },
905 { .compatible
= "nvidia,tegra124-sor", },
906 { .compatible
= "nvidia,tegra124-hdmi", },
910 static struct host1x_driver host1x_drm_driver
= {
912 .probe
= host1x_drm_probe
,
913 .remove
= host1x_drm_remove
,
914 .subdevs
= host1x_drm_subdevs
,
917 static int __init
host1x_drm_init(void)
921 err
= host1x_driver_register(&host1x_drm_driver
);
925 err
= platform_driver_register(&tegra_dc_driver
);
927 goto unregister_host1x
;
929 err
= platform_driver_register(&tegra_dsi_driver
);
933 err
= platform_driver_register(&tegra_sor_driver
);
937 err
= platform_driver_register(&tegra_hdmi_driver
);
941 err
= platform_driver_register(&tegra_dpaux_driver
);
943 goto unregister_hdmi
;
945 err
= platform_driver_register(&tegra_gr2d_driver
);
947 goto unregister_dpaux
;
949 err
= platform_driver_register(&tegra_gr3d_driver
);
951 goto unregister_gr2d
;
956 platform_driver_unregister(&tegra_gr2d_driver
);
958 platform_driver_unregister(&tegra_dpaux_driver
);
960 platform_driver_unregister(&tegra_hdmi_driver
);
962 platform_driver_unregister(&tegra_sor_driver
);
964 platform_driver_unregister(&tegra_dsi_driver
);
966 platform_driver_unregister(&tegra_dc_driver
);
968 host1x_driver_unregister(&host1x_drm_driver
);
971 module_init(host1x_drm_init
);
973 static void __exit
host1x_drm_exit(void)
975 platform_driver_unregister(&tegra_gr3d_driver
);
976 platform_driver_unregister(&tegra_gr2d_driver
);
977 platform_driver_unregister(&tegra_dpaux_driver
);
978 platform_driver_unregister(&tegra_hdmi_driver
);
979 platform_driver_unregister(&tegra_sor_driver
);
980 platform_driver_unregister(&tegra_dsi_driver
);
981 platform_driver_unregister(&tegra_dc_driver
);
982 host1x_driver_unregister(&host1x_drm_driver
);
984 module_exit(host1x_drm_exit
);
986 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
987 MODULE_DESCRIPTION("NVIDIA Tegra DRM driver");
988 MODULE_LICENSE("GPL v2");