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>
15 #define DRIVER_NAME "tegra"
16 #define DRIVER_DESC "NVIDIA Tegra graphics"
17 #define DRIVER_DATE "20120330"
18 #define DRIVER_MAJOR 0
19 #define DRIVER_MINOR 0
20 #define DRIVER_PATCHLEVEL 0
22 struct tegra_drm_file
{
23 struct list_head contexts
;
26 static int tegra_drm_load(struct drm_device
*drm
, unsigned long flags
)
28 struct host1x_device
*device
= to_host1x_device(drm
->dev
);
29 struct tegra_drm
*tegra
;
32 tegra
= kzalloc(sizeof(*tegra
), GFP_KERNEL
);
36 mutex_init(&tegra
->clients_lock
);
37 INIT_LIST_HEAD(&tegra
->clients
);
38 drm
->dev_private
= tegra
;
41 drm_mode_config_init(drm
);
43 err
= tegra_drm_fb_prepare(drm
);
47 drm_kms_helper_poll_init(drm
);
49 err
= host1x_device_init(device
);
54 * We don't use the drm_irq_install() helpers provided by the DRM
55 * core, so we need to set this manually in order to allow the
56 * DRM_IOCTL_WAIT_VBLANK to operate correctly.
58 drm
->irq_enabled
= true;
60 err
= drm_vblank_init(drm
, drm
->mode_config
.num_crtc
);
64 err
= tegra_drm_fb_init(drm
);
71 static int tegra_drm_unload(struct drm_device
*drm
)
73 struct host1x_device
*device
= to_host1x_device(drm
->dev
);
76 drm_kms_helper_poll_fini(drm
);
77 tegra_drm_fb_exit(drm
);
78 drm_vblank_cleanup(drm
);
79 drm_mode_config_cleanup(drm
);
81 err
= host1x_device_exit(device
);
88 static int tegra_drm_open(struct drm_device
*drm
, struct drm_file
*filp
)
90 struct tegra_drm_file
*fpriv
;
92 fpriv
= kzalloc(sizeof(*fpriv
), GFP_KERNEL
);
96 INIT_LIST_HEAD(&fpriv
->contexts
);
97 filp
->driver_priv
= fpriv
;
102 static void tegra_drm_context_free(struct tegra_drm_context
*context
)
104 context
->client
->ops
->close_channel(context
);
108 static void tegra_drm_lastclose(struct drm_device
*drm
)
110 #ifdef CONFIG_DRM_TEGRA_FBDEV
111 struct tegra_drm
*tegra
= drm
->dev_private
;
113 tegra_fbdev_restore_mode(tegra
->fbdev
);
117 static struct host1x_bo
*
118 host1x_bo_lookup(struct drm_device
*drm
, struct drm_file
*file
, u32 handle
)
120 struct drm_gem_object
*gem
;
123 gem
= drm_gem_object_lookup(drm
, file
, handle
);
127 mutex_lock(&drm
->struct_mutex
);
128 drm_gem_object_unreference(gem
);
129 mutex_unlock(&drm
->struct_mutex
);
131 bo
= to_tegra_bo(gem
);
135 static int host1x_reloc_copy_from_user(struct host1x_reloc
*dest
,
136 struct drm_tegra_reloc __user
*src
,
137 struct drm_device
*drm
,
138 struct drm_file
*file
)
143 err
= get_user(cmdbuf
, &src
->cmdbuf
.handle
);
147 err
= get_user(dest
->cmdbuf
.offset
, &src
->cmdbuf
.offset
);
151 err
= get_user(target
, &src
->target
.handle
);
155 err
= get_user(dest
->target
.offset
, &src
->cmdbuf
.offset
);
159 err
= get_user(dest
->shift
, &src
->shift
);
163 dest
->cmdbuf
.bo
= host1x_bo_lookup(drm
, file
, cmdbuf
);
164 if (!dest
->cmdbuf
.bo
)
167 dest
->target
.bo
= host1x_bo_lookup(drm
, file
, target
);
168 if (!dest
->target
.bo
)
174 int tegra_drm_submit(struct tegra_drm_context
*context
,
175 struct drm_tegra_submit
*args
, struct drm_device
*drm
,
176 struct drm_file
*file
)
178 unsigned int num_cmdbufs
= args
->num_cmdbufs
;
179 unsigned int num_relocs
= args
->num_relocs
;
180 unsigned int num_waitchks
= args
->num_waitchks
;
181 struct drm_tegra_cmdbuf __user
*cmdbufs
=
182 (void __user
*)(uintptr_t)args
->cmdbufs
;
183 struct drm_tegra_reloc __user
*relocs
=
184 (void __user
*)(uintptr_t)args
->relocs
;
185 struct drm_tegra_waitchk __user
*waitchks
=
186 (void __user
*)(uintptr_t)args
->waitchks
;
187 struct drm_tegra_syncpt syncpt
;
188 struct host1x_job
*job
;
191 /* We don't yet support other than one syncpt_incr struct per submit */
192 if (args
->num_syncpts
!= 1)
195 job
= host1x_job_alloc(context
->channel
, args
->num_cmdbufs
,
196 args
->num_relocs
, args
->num_waitchks
);
200 job
->num_relocs
= args
->num_relocs
;
201 job
->num_waitchk
= args
->num_waitchks
;
202 job
->client
= (u32
)args
->context
;
203 job
->class = context
->client
->base
.class;
204 job
->serialize
= true;
206 while (num_cmdbufs
) {
207 struct drm_tegra_cmdbuf cmdbuf
;
208 struct host1x_bo
*bo
;
210 if (copy_from_user(&cmdbuf
, cmdbufs
, sizeof(cmdbuf
))) {
215 bo
= host1x_bo_lookup(drm
, file
, cmdbuf
.handle
);
221 host1x_job_add_gather(job
, bo
, cmdbuf
.words
, cmdbuf
.offset
);
226 /* copy and resolve relocations from submit */
227 while (num_relocs
--) {
228 err
= host1x_reloc_copy_from_user(&job
->relocarray
[num_relocs
],
229 &relocs
[num_relocs
], drm
,
235 if (copy_from_user(job
->waitchk
, waitchks
,
236 sizeof(*waitchks
) * num_waitchks
)) {
241 if (copy_from_user(&syncpt
, (void __user
*)(uintptr_t)args
->syncpts
,
247 job
->is_addr_reg
= context
->client
->ops
->is_addr_reg
;
248 job
->syncpt_incrs
= syncpt
.incrs
;
249 job
->syncpt_id
= syncpt
.id
;
250 job
->timeout
= 10000;
252 if (args
->timeout
&& args
->timeout
< 10000)
253 job
->timeout
= args
->timeout
;
255 err
= host1x_job_pin(job
, context
->client
->base
.dev
);
259 err
= host1x_job_submit(job
);
263 args
->fence
= job
->syncpt_end
;
269 host1x_job_unpin(job
);
276 #ifdef CONFIG_DRM_TEGRA_STAGING
277 static struct tegra_drm_context
*tegra_drm_get_context(__u64 context
)
279 return (struct tegra_drm_context
*)(uintptr_t)context
;
282 static bool tegra_drm_file_owns_context(struct tegra_drm_file
*file
,
283 struct tegra_drm_context
*context
)
285 struct tegra_drm_context
*ctx
;
287 list_for_each_entry(ctx
, &file
->contexts
, list
)
294 static int tegra_gem_create(struct drm_device
*drm
, void *data
,
295 struct drm_file
*file
)
297 struct drm_tegra_gem_create
*args
= data
;
300 bo
= tegra_bo_create_with_handle(file
, drm
, args
->size
, args
->flags
,
308 static int tegra_gem_mmap(struct drm_device
*drm
, void *data
,
309 struct drm_file
*file
)
311 struct drm_tegra_gem_mmap
*args
= data
;
312 struct drm_gem_object
*gem
;
315 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
319 bo
= to_tegra_bo(gem
);
321 args
->offset
= drm_vma_node_offset_addr(&bo
->gem
.vma_node
);
323 drm_gem_object_unreference(gem
);
328 static int tegra_syncpt_read(struct drm_device
*drm
, void *data
,
329 struct drm_file
*file
)
331 struct host1x
*host
= dev_get_drvdata(drm
->dev
->parent
);
332 struct drm_tegra_syncpt_read
*args
= data
;
333 struct host1x_syncpt
*sp
;
335 sp
= host1x_syncpt_get(host
, args
->id
);
339 args
->value
= host1x_syncpt_read_min(sp
);
343 static int tegra_syncpt_incr(struct drm_device
*drm
, void *data
,
344 struct drm_file
*file
)
346 struct host1x
*host1x
= dev_get_drvdata(drm
->dev
->parent
);
347 struct drm_tegra_syncpt_incr
*args
= data
;
348 struct host1x_syncpt
*sp
;
350 sp
= host1x_syncpt_get(host1x
, args
->id
);
354 return host1x_syncpt_incr(sp
);
357 static int tegra_syncpt_wait(struct drm_device
*drm
, void *data
,
358 struct drm_file
*file
)
360 struct host1x
*host1x
= dev_get_drvdata(drm
->dev
->parent
);
361 struct drm_tegra_syncpt_wait
*args
= data
;
362 struct host1x_syncpt
*sp
;
364 sp
= host1x_syncpt_get(host1x
, args
->id
);
368 return host1x_syncpt_wait(sp
, args
->thresh
, args
->timeout
,
372 static int tegra_open_channel(struct drm_device
*drm
, void *data
,
373 struct drm_file
*file
)
375 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
376 struct tegra_drm
*tegra
= drm
->dev_private
;
377 struct drm_tegra_open_channel
*args
= data
;
378 struct tegra_drm_context
*context
;
379 struct tegra_drm_client
*client
;
382 context
= kzalloc(sizeof(*context
), GFP_KERNEL
);
386 list_for_each_entry(client
, &tegra
->clients
, list
)
387 if (client
->base
.class == args
->client
) {
388 err
= client
->ops
->open_channel(client
, context
);
392 list_add(&context
->list
, &fpriv
->contexts
);
393 args
->context
= (uintptr_t)context
;
394 context
->client
= client
;
402 static int tegra_close_channel(struct drm_device
*drm
, void *data
,
403 struct drm_file
*file
)
405 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
406 struct drm_tegra_close_channel
*args
= data
;
407 struct tegra_drm_context
*context
;
409 context
= tegra_drm_get_context(args
->context
);
411 if (!tegra_drm_file_owns_context(fpriv
, context
))
414 list_del(&context
->list
);
415 tegra_drm_context_free(context
);
420 static int tegra_get_syncpt(struct drm_device
*drm
, void *data
,
421 struct drm_file
*file
)
423 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
424 struct drm_tegra_get_syncpt
*args
= data
;
425 struct tegra_drm_context
*context
;
426 struct host1x_syncpt
*syncpt
;
428 context
= tegra_drm_get_context(args
->context
);
430 if (!tegra_drm_file_owns_context(fpriv
, context
))
433 if (args
->index
>= context
->client
->base
.num_syncpts
)
436 syncpt
= context
->client
->base
.syncpts
[args
->index
];
437 args
->id
= host1x_syncpt_id(syncpt
);
442 static int tegra_submit(struct drm_device
*drm
, void *data
,
443 struct drm_file
*file
)
445 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
446 struct drm_tegra_submit
*args
= data
;
447 struct tegra_drm_context
*context
;
449 context
= tegra_drm_get_context(args
->context
);
451 if (!tegra_drm_file_owns_context(fpriv
, context
))
454 return context
->client
->ops
->submit(context
, args
, drm
, file
);
457 static int tegra_get_syncpt_base(struct drm_device
*drm
, void *data
,
458 struct drm_file
*file
)
460 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
461 struct drm_tegra_get_syncpt_base
*args
= data
;
462 struct tegra_drm_context
*context
;
463 struct host1x_syncpt_base
*base
;
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
->syncpt
>= context
->client
->base
.num_syncpts
)
474 syncpt
= context
->client
->base
.syncpts
[args
->syncpt
];
476 base
= host1x_syncpt_get_base(syncpt
);
480 args
->id
= host1x_syncpt_base_id(base
);
485 static int tegra_gem_set_tiling(struct drm_device
*drm
, void *data
,
486 struct drm_file
*file
)
488 struct drm_tegra_gem_set_tiling
*args
= data
;
489 enum tegra_bo_tiling_mode mode
;
490 struct drm_gem_object
*gem
;
491 unsigned long value
= 0;
494 switch (args
->mode
) {
495 case DRM_TEGRA_GEM_TILING_MODE_PITCH
:
496 mode
= TEGRA_BO_TILING_MODE_PITCH
;
498 if (args
->value
!= 0)
503 case DRM_TEGRA_GEM_TILING_MODE_TILED
:
504 mode
= TEGRA_BO_TILING_MODE_TILED
;
506 if (args
->value
!= 0)
511 case DRM_TEGRA_GEM_TILING_MODE_BLOCK
:
512 mode
= TEGRA_BO_TILING_MODE_BLOCK
;
524 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
528 bo
= to_tegra_bo(gem
);
530 bo
->tiling
.mode
= mode
;
531 bo
->tiling
.value
= value
;
533 drm_gem_object_unreference(gem
);
538 static int tegra_gem_get_tiling(struct drm_device
*drm
, void *data
,
539 struct drm_file
*file
)
541 struct drm_tegra_gem_get_tiling
*args
= data
;
542 struct drm_gem_object
*gem
;
546 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
550 bo
= to_tegra_bo(gem
);
552 switch (bo
->tiling
.mode
) {
553 case TEGRA_BO_TILING_MODE_PITCH
:
554 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_PITCH
;
558 case TEGRA_BO_TILING_MODE_TILED
:
559 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_TILED
;
563 case TEGRA_BO_TILING_MODE_BLOCK
:
564 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_BLOCK
;
565 args
->value
= bo
->tiling
.value
;
573 drm_gem_object_unreference(gem
);
578 static int tegra_gem_set_flags(struct drm_device
*drm
, void *data
,
579 struct drm_file
*file
)
581 struct drm_tegra_gem_set_flags
*args
= data
;
582 struct drm_gem_object
*gem
;
585 if (args
->flags
& ~DRM_TEGRA_GEM_FLAGS
)
588 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
592 bo
= to_tegra_bo(gem
);
595 if (args
->flags
& DRM_TEGRA_GEM_BOTTOM_UP
)
596 bo
->flags
|= TEGRA_BO_BOTTOM_UP
;
598 drm_gem_object_unreference(gem
);
603 static int tegra_gem_get_flags(struct drm_device
*drm
, void *data
,
604 struct drm_file
*file
)
606 struct drm_tegra_gem_get_flags
*args
= data
;
607 struct drm_gem_object
*gem
;
610 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
614 bo
= to_tegra_bo(gem
);
617 if (bo
->flags
& TEGRA_BO_BOTTOM_UP
)
618 args
->flags
|= DRM_TEGRA_GEM_BOTTOM_UP
;
620 drm_gem_object_unreference(gem
);
626 static const struct drm_ioctl_desc tegra_drm_ioctls
[] = {
627 #ifdef CONFIG_DRM_TEGRA_STAGING
628 DRM_IOCTL_DEF_DRV(TEGRA_GEM_CREATE
, tegra_gem_create
, DRM_UNLOCKED
),
629 DRM_IOCTL_DEF_DRV(TEGRA_GEM_MMAP
, tegra_gem_mmap
, DRM_UNLOCKED
),
630 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_READ
, tegra_syncpt_read
, DRM_UNLOCKED
),
631 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_INCR
, tegra_syncpt_incr
, DRM_UNLOCKED
),
632 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_WAIT
, tegra_syncpt_wait
, DRM_UNLOCKED
),
633 DRM_IOCTL_DEF_DRV(TEGRA_OPEN_CHANNEL
, tegra_open_channel
, DRM_UNLOCKED
),
634 DRM_IOCTL_DEF_DRV(TEGRA_CLOSE_CHANNEL
, tegra_close_channel
, DRM_UNLOCKED
),
635 DRM_IOCTL_DEF_DRV(TEGRA_GET_SYNCPT
, tegra_get_syncpt
, DRM_UNLOCKED
),
636 DRM_IOCTL_DEF_DRV(TEGRA_SUBMIT
, tegra_submit
, DRM_UNLOCKED
),
637 DRM_IOCTL_DEF_DRV(TEGRA_GET_SYNCPT_BASE
, tegra_get_syncpt_base
, DRM_UNLOCKED
),
638 DRM_IOCTL_DEF_DRV(TEGRA_GEM_SET_TILING
, tegra_gem_set_tiling
, DRM_UNLOCKED
),
639 DRM_IOCTL_DEF_DRV(TEGRA_GEM_GET_TILING
, tegra_gem_get_tiling
, DRM_UNLOCKED
),
640 DRM_IOCTL_DEF_DRV(TEGRA_GEM_SET_FLAGS
, tegra_gem_set_flags
, DRM_UNLOCKED
),
641 DRM_IOCTL_DEF_DRV(TEGRA_GEM_GET_FLAGS
, tegra_gem_get_flags
, DRM_UNLOCKED
),
645 static const struct file_operations tegra_drm_fops
= {
646 .owner
= THIS_MODULE
,
648 .release
= drm_release
,
649 .unlocked_ioctl
= drm_ioctl
,
650 .mmap
= tegra_drm_mmap
,
654 .compat_ioctl
= drm_compat_ioctl
,
656 .llseek
= noop_llseek
,
659 static struct drm_crtc
*tegra_crtc_from_pipe(struct drm_device
*drm
, int pipe
)
661 struct drm_crtc
*crtc
;
663 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
) {
664 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
666 if (dc
->pipe
== pipe
)
673 static u32
tegra_drm_get_vblank_counter(struct drm_device
*dev
, int crtc
)
675 /* TODO: implement real hardware counter using syncpoints */
676 return drm_vblank_count(dev
, crtc
);
679 static int tegra_drm_enable_vblank(struct drm_device
*drm
, int pipe
)
681 struct drm_crtc
*crtc
= tegra_crtc_from_pipe(drm
, pipe
);
682 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
687 tegra_dc_enable_vblank(dc
);
692 static void tegra_drm_disable_vblank(struct drm_device
*drm
, int pipe
)
694 struct drm_crtc
*crtc
= tegra_crtc_from_pipe(drm
, pipe
);
695 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
698 tegra_dc_disable_vblank(dc
);
701 static void tegra_drm_preclose(struct drm_device
*drm
, struct drm_file
*file
)
703 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
704 struct tegra_drm_context
*context
, *tmp
;
705 struct drm_crtc
*crtc
;
707 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
)
708 tegra_dc_cancel_page_flip(crtc
, file
);
710 list_for_each_entry_safe(context
, tmp
, &fpriv
->contexts
, list
)
711 tegra_drm_context_free(context
);
716 #ifdef CONFIG_DEBUG_FS
717 static int tegra_debugfs_framebuffers(struct seq_file
*s
, void *data
)
719 struct drm_info_node
*node
= (struct drm_info_node
*)s
->private;
720 struct drm_device
*drm
= node
->minor
->dev
;
721 struct drm_framebuffer
*fb
;
723 mutex_lock(&drm
->mode_config
.fb_lock
);
725 list_for_each_entry(fb
, &drm
->mode_config
.fb_list
, head
) {
726 seq_printf(s
, "%3d: user size: %d x %d, depth %d, %d bpp, refcount %d\n",
727 fb
->base
.id
, fb
->width
, fb
->height
, fb
->depth
,
729 atomic_read(&fb
->refcount
.refcount
));
732 mutex_unlock(&drm
->mode_config
.fb_lock
);
737 static struct drm_info_list tegra_debugfs_list
[] = {
738 { "framebuffers", tegra_debugfs_framebuffers
, 0 },
741 static int tegra_debugfs_init(struct drm_minor
*minor
)
743 return drm_debugfs_create_files(tegra_debugfs_list
,
744 ARRAY_SIZE(tegra_debugfs_list
),
745 minor
->debugfs_root
, minor
);
748 static void tegra_debugfs_cleanup(struct drm_minor
*minor
)
750 drm_debugfs_remove_files(tegra_debugfs_list
,
751 ARRAY_SIZE(tegra_debugfs_list
), minor
);
755 static struct drm_driver tegra_drm_driver
= {
756 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
| DRIVER_PRIME
,
757 .load
= tegra_drm_load
,
758 .unload
= tegra_drm_unload
,
759 .open
= tegra_drm_open
,
760 .preclose
= tegra_drm_preclose
,
761 .lastclose
= tegra_drm_lastclose
,
763 .get_vblank_counter
= tegra_drm_get_vblank_counter
,
764 .enable_vblank
= tegra_drm_enable_vblank
,
765 .disable_vblank
= tegra_drm_disable_vblank
,
767 #if defined(CONFIG_DEBUG_FS)
768 .debugfs_init
= tegra_debugfs_init
,
769 .debugfs_cleanup
= tegra_debugfs_cleanup
,
772 .gem_free_object
= tegra_bo_free_object
,
773 .gem_vm_ops
= &tegra_bo_vm_ops
,
775 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
776 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
777 .gem_prime_export
= tegra_gem_prime_export
,
778 .gem_prime_import
= tegra_gem_prime_import
,
780 .dumb_create
= tegra_bo_dumb_create
,
781 .dumb_map_offset
= tegra_bo_dumb_map_offset
,
782 .dumb_destroy
= drm_gem_dumb_destroy
,
784 .ioctls
= tegra_drm_ioctls
,
785 .num_ioctls
= ARRAY_SIZE(tegra_drm_ioctls
),
786 .fops
= &tegra_drm_fops
,
791 .major
= DRIVER_MAJOR
,
792 .minor
= DRIVER_MINOR
,
793 .patchlevel
= DRIVER_PATCHLEVEL
,
796 int tegra_drm_register_client(struct tegra_drm
*tegra
,
797 struct tegra_drm_client
*client
)
799 mutex_lock(&tegra
->clients_lock
);
800 list_add_tail(&client
->list
, &tegra
->clients
);
801 mutex_unlock(&tegra
->clients_lock
);
806 int tegra_drm_unregister_client(struct tegra_drm
*tegra
,
807 struct tegra_drm_client
*client
)
809 mutex_lock(&tegra
->clients_lock
);
810 list_del_init(&client
->list
);
811 mutex_unlock(&tegra
->clients_lock
);
816 static int host1x_drm_probe(struct host1x_device
*dev
)
818 struct drm_driver
*driver
= &tegra_drm_driver
;
819 struct drm_device
*drm
;
822 drm
= drm_dev_alloc(driver
, &dev
->dev
);
826 drm_dev_set_unique(drm
, dev_name(&dev
->dev
));
827 dev_set_drvdata(&dev
->dev
, drm
);
829 err
= drm_dev_register(drm
, 0);
833 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", driver
->name
,
834 driver
->major
, driver
->minor
, driver
->patchlevel
,
835 driver
->date
, drm
->primary
->index
);
844 static int host1x_drm_remove(struct host1x_device
*dev
)
846 struct drm_device
*drm
= dev_get_drvdata(&dev
->dev
);
848 drm_dev_unregister(drm
);
854 static const struct of_device_id host1x_drm_subdevs
[] = {
855 { .compatible
= "nvidia,tegra20-dc", },
856 { .compatible
= "nvidia,tegra20-hdmi", },
857 { .compatible
= "nvidia,tegra20-gr2d", },
858 { .compatible
= "nvidia,tegra20-gr3d", },
859 { .compatible
= "nvidia,tegra30-dc", },
860 { .compatible
= "nvidia,tegra30-hdmi", },
861 { .compatible
= "nvidia,tegra30-gr2d", },
862 { .compatible
= "nvidia,tegra30-gr3d", },
863 { .compatible
= "nvidia,tegra114-dsi", },
864 { .compatible
= "nvidia,tegra114-hdmi", },
865 { .compatible
= "nvidia,tegra114-gr3d", },
866 { .compatible
= "nvidia,tegra124-dc", },
867 { .compatible
= "nvidia,tegra124-sor", },
868 { .compatible
= "nvidia,tegra124-hdmi", },
872 static struct host1x_driver host1x_drm_driver
= {
874 .probe
= host1x_drm_probe
,
875 .remove
= host1x_drm_remove
,
876 .subdevs
= host1x_drm_subdevs
,
879 static int __init
host1x_drm_init(void)
883 err
= host1x_driver_register(&host1x_drm_driver
);
887 err
= platform_driver_register(&tegra_dc_driver
);
889 goto unregister_host1x
;
891 err
= platform_driver_register(&tegra_dsi_driver
);
895 err
= platform_driver_register(&tegra_sor_driver
);
899 err
= platform_driver_register(&tegra_hdmi_driver
);
903 err
= platform_driver_register(&tegra_dpaux_driver
);
905 goto unregister_hdmi
;
907 err
= platform_driver_register(&tegra_gr2d_driver
);
909 goto unregister_dpaux
;
911 err
= platform_driver_register(&tegra_gr3d_driver
);
913 goto unregister_gr2d
;
918 platform_driver_unregister(&tegra_gr2d_driver
);
920 platform_driver_unregister(&tegra_dpaux_driver
);
922 platform_driver_unregister(&tegra_hdmi_driver
);
924 platform_driver_unregister(&tegra_sor_driver
);
926 platform_driver_unregister(&tegra_dsi_driver
);
928 platform_driver_unregister(&tegra_dc_driver
);
930 host1x_driver_unregister(&host1x_drm_driver
);
933 module_init(host1x_drm_init
);
935 static void __exit
host1x_drm_exit(void)
937 platform_driver_unregister(&tegra_gr3d_driver
);
938 platform_driver_unregister(&tegra_gr2d_driver
);
939 platform_driver_unregister(&tegra_dpaux_driver
);
940 platform_driver_unregister(&tegra_hdmi_driver
);
941 platform_driver_unregister(&tegra_sor_driver
);
942 platform_driver_unregister(&tegra_dsi_driver
);
943 platform_driver_unregister(&tegra_dc_driver
);
944 host1x_driver_unregister(&host1x_drm_driver
);
946 module_exit(host1x_drm_exit
);
948 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
949 MODULE_DESCRIPTION("NVIDIA Tegra DRM driver");
950 MODULE_LICENSE("GPL v2");