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>
13 #include <drm/drm_atomic.h>
14 #include <drm/drm_atomic_helper.h>
19 #define DRIVER_NAME "tegra"
20 #define DRIVER_DESC "NVIDIA Tegra graphics"
21 #define DRIVER_DATE "20120330"
22 #define DRIVER_MAJOR 0
23 #define DRIVER_MINOR 0
24 #define DRIVER_PATCHLEVEL 0
26 struct tegra_drm_file
{
27 struct list_head contexts
;
30 static void tegra_atomic_schedule(struct tegra_drm
*tegra
,
31 struct drm_atomic_state
*state
)
33 tegra
->commit
.state
= state
;
34 schedule_work(&tegra
->commit
.work
);
37 static void tegra_atomic_complete(struct tegra_drm
*tegra
,
38 struct drm_atomic_state
*state
)
40 struct drm_device
*drm
= tegra
->drm
;
43 * Everything below can be run asynchronously without the need to grab
44 * any modeset locks at all under one condition: It must be guaranteed
45 * that the asynchronous work has either been cancelled (if the driver
46 * supports it, which at least requires that the framebuffers get
47 * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
48 * before the new state gets committed on the software side with
49 * drm_atomic_helper_swap_state().
51 * This scheme allows new atomic state updates to be prepared and
52 * checked in parallel to the asynchronous completion of the previous
53 * update. Which is important since compositors need to figure out the
54 * composition of the next frame right after having submitted the
58 drm_atomic_helper_commit_modeset_disables(drm
, state
);
59 drm_atomic_helper_commit_planes(drm
, state
);
60 drm_atomic_helper_commit_modeset_enables(drm
, state
);
62 drm_atomic_helper_wait_for_vblanks(drm
, state
);
64 drm_atomic_helper_cleanup_planes(drm
, state
);
65 drm_atomic_state_free(state
);
68 static void tegra_atomic_work(struct work_struct
*work
)
70 struct tegra_drm
*tegra
= container_of(work
, struct tegra_drm
,
73 tegra_atomic_complete(tegra
, tegra
->commit
.state
);
76 static int tegra_atomic_commit(struct drm_device
*drm
,
77 struct drm_atomic_state
*state
, bool async
)
79 struct tegra_drm
*tegra
= drm
->dev_private
;
82 err
= drm_atomic_helper_prepare_planes(drm
, state
);
86 /* serialize outstanding asynchronous commits */
87 mutex_lock(&tegra
->commit
.lock
);
88 flush_work(&tegra
->commit
.work
);
91 * This is the point of no return - everything below never fails except
92 * when the hw goes bonghits. Which means we can commit the new state on
93 * the software side now.
96 drm_atomic_helper_swap_state(drm
, state
);
99 tegra_atomic_schedule(tegra
, state
);
101 tegra_atomic_complete(tegra
, state
);
103 mutex_unlock(&tegra
->commit
.lock
);
107 static const struct drm_mode_config_funcs tegra_drm_mode_funcs
= {
108 .fb_create
= tegra_fb_create
,
109 #ifdef CONFIG_DRM_TEGRA_FBDEV
110 .output_poll_changed
= tegra_fb_output_poll_changed
,
112 .atomic_check
= drm_atomic_helper_check
,
113 .atomic_commit
= tegra_atomic_commit
,
116 static int tegra_drm_load(struct drm_device
*drm
, unsigned long flags
)
118 struct host1x_device
*device
= to_host1x_device(drm
->dev
);
119 struct tegra_drm
*tegra
;
122 tegra
= kzalloc(sizeof(*tegra
), GFP_KERNEL
);
126 if (iommu_present(&platform_bus_type
)) {
127 struct iommu_domain_geometry
*geometry
;
130 tegra
->domain
= iommu_domain_alloc(&platform_bus_type
);
131 if (!tegra
->domain
) {
136 geometry
= &tegra
->domain
->geometry
;
137 start
= geometry
->aperture_start
;
138 end
= geometry
->aperture_end
;
140 DRM_DEBUG("IOMMU context initialized (aperture: %#llx-%#llx)\n",
142 drm_mm_init(&tegra
->mm
, start
, end
- start
+ 1);
145 mutex_init(&tegra
->clients_lock
);
146 INIT_LIST_HEAD(&tegra
->clients
);
148 mutex_init(&tegra
->commit
.lock
);
149 INIT_WORK(&tegra
->commit
.work
, tegra_atomic_work
);
151 drm
->dev_private
= tegra
;
154 drm_mode_config_init(drm
);
156 drm
->mode_config
.min_width
= 0;
157 drm
->mode_config
.min_height
= 0;
159 drm
->mode_config
.max_width
= 4096;
160 drm
->mode_config
.max_height
= 4096;
162 drm
->mode_config
.funcs
= &tegra_drm_mode_funcs
;
164 err
= tegra_drm_fb_prepare(drm
);
168 drm_kms_helper_poll_init(drm
);
170 err
= host1x_device_init(device
);
175 * We don't use the drm_irq_install() helpers provided by the DRM
176 * core, so we need to set this manually in order to allow the
177 * DRM_IOCTL_WAIT_VBLANK to operate correctly.
179 drm
->irq_enabled
= true;
181 /* syncpoints are used for full 32-bit hardware VBLANK counters */
182 drm
->max_vblank_count
= 0xffffffff;
183 drm
->vblank_disable_allowed
= true;
185 err
= drm_vblank_init(drm
, drm
->mode_config
.num_crtc
);
189 drm_mode_config_reset(drm
);
191 err
= tegra_drm_fb_init(drm
);
198 drm_vblank_cleanup(drm
);
200 host1x_device_exit(device
);
202 drm_kms_helper_poll_fini(drm
);
203 tegra_drm_fb_free(drm
);
205 drm_mode_config_cleanup(drm
);
208 iommu_domain_free(tegra
->domain
);
209 drm_mm_takedown(&tegra
->mm
);
216 static int tegra_drm_unload(struct drm_device
*drm
)
218 struct host1x_device
*device
= to_host1x_device(drm
->dev
);
219 struct tegra_drm
*tegra
= drm
->dev_private
;
222 drm_kms_helper_poll_fini(drm
);
223 tegra_drm_fb_exit(drm
);
224 drm_mode_config_cleanup(drm
);
225 drm_vblank_cleanup(drm
);
227 err
= host1x_device_exit(device
);
232 iommu_domain_free(tegra
->domain
);
233 drm_mm_takedown(&tegra
->mm
);
241 static int tegra_drm_open(struct drm_device
*drm
, struct drm_file
*filp
)
243 struct tegra_drm_file
*fpriv
;
245 fpriv
= kzalloc(sizeof(*fpriv
), GFP_KERNEL
);
249 INIT_LIST_HEAD(&fpriv
->contexts
);
250 filp
->driver_priv
= fpriv
;
255 static void tegra_drm_context_free(struct tegra_drm_context
*context
)
257 context
->client
->ops
->close_channel(context
);
261 static void tegra_drm_lastclose(struct drm_device
*drm
)
263 #ifdef CONFIG_DRM_TEGRA_FBDEV
264 struct tegra_drm
*tegra
= drm
->dev_private
;
266 tegra_fbdev_restore_mode(tegra
->fbdev
);
270 static struct host1x_bo
*
271 host1x_bo_lookup(struct drm_device
*drm
, struct drm_file
*file
, u32 handle
)
273 struct drm_gem_object
*gem
;
276 gem
= drm_gem_object_lookup(drm
, file
, handle
);
280 mutex_lock(&drm
->struct_mutex
);
281 drm_gem_object_unreference(gem
);
282 mutex_unlock(&drm
->struct_mutex
);
284 bo
= to_tegra_bo(gem
);
288 static int host1x_reloc_copy_from_user(struct host1x_reloc
*dest
,
289 struct drm_tegra_reloc __user
*src
,
290 struct drm_device
*drm
,
291 struct drm_file
*file
)
296 err
= get_user(cmdbuf
, &src
->cmdbuf
.handle
);
300 err
= get_user(dest
->cmdbuf
.offset
, &src
->cmdbuf
.offset
);
304 err
= get_user(target
, &src
->target
.handle
);
308 err
= get_user(dest
->target
.offset
, &src
->target
.offset
);
312 err
= get_user(dest
->shift
, &src
->shift
);
316 dest
->cmdbuf
.bo
= host1x_bo_lookup(drm
, file
, cmdbuf
);
317 if (!dest
->cmdbuf
.bo
)
320 dest
->target
.bo
= host1x_bo_lookup(drm
, file
, target
);
321 if (!dest
->target
.bo
)
327 int tegra_drm_submit(struct tegra_drm_context
*context
,
328 struct drm_tegra_submit
*args
, struct drm_device
*drm
,
329 struct drm_file
*file
)
331 unsigned int num_cmdbufs
= args
->num_cmdbufs
;
332 unsigned int num_relocs
= args
->num_relocs
;
333 unsigned int num_waitchks
= args
->num_waitchks
;
334 struct drm_tegra_cmdbuf __user
*cmdbufs
=
335 (void __user
*)(uintptr_t)args
->cmdbufs
;
336 struct drm_tegra_reloc __user
*relocs
=
337 (void __user
*)(uintptr_t)args
->relocs
;
338 struct drm_tegra_waitchk __user
*waitchks
=
339 (void __user
*)(uintptr_t)args
->waitchks
;
340 struct drm_tegra_syncpt syncpt
;
341 struct host1x_job
*job
;
344 /* We don't yet support other than one syncpt_incr struct per submit */
345 if (args
->num_syncpts
!= 1)
348 job
= host1x_job_alloc(context
->channel
, args
->num_cmdbufs
,
349 args
->num_relocs
, args
->num_waitchks
);
353 job
->num_relocs
= args
->num_relocs
;
354 job
->num_waitchk
= args
->num_waitchks
;
355 job
->client
= (u32
)args
->context
;
356 job
->class = context
->client
->base
.class;
357 job
->serialize
= true;
359 while (num_cmdbufs
) {
360 struct drm_tegra_cmdbuf cmdbuf
;
361 struct host1x_bo
*bo
;
363 if (copy_from_user(&cmdbuf
, cmdbufs
, sizeof(cmdbuf
))) {
368 bo
= host1x_bo_lookup(drm
, file
, cmdbuf
.handle
);
374 host1x_job_add_gather(job
, bo
, cmdbuf
.words
, cmdbuf
.offset
);
379 /* copy and resolve relocations from submit */
380 while (num_relocs
--) {
381 err
= host1x_reloc_copy_from_user(&job
->relocarray
[num_relocs
],
382 &relocs
[num_relocs
], drm
,
388 if (copy_from_user(job
->waitchk
, waitchks
,
389 sizeof(*waitchks
) * num_waitchks
)) {
394 if (copy_from_user(&syncpt
, (void __user
*)(uintptr_t)args
->syncpts
,
400 job
->is_addr_reg
= context
->client
->ops
->is_addr_reg
;
401 job
->syncpt_incrs
= syncpt
.incrs
;
402 job
->syncpt_id
= syncpt
.id
;
403 job
->timeout
= 10000;
405 if (args
->timeout
&& args
->timeout
< 10000)
406 job
->timeout
= args
->timeout
;
408 err
= host1x_job_pin(job
, context
->client
->base
.dev
);
412 err
= host1x_job_submit(job
);
416 args
->fence
= job
->syncpt_end
;
422 host1x_job_unpin(job
);
429 #ifdef CONFIG_DRM_TEGRA_STAGING
430 static struct tegra_drm_context
*tegra_drm_get_context(__u64 context
)
432 return (struct tegra_drm_context
*)(uintptr_t)context
;
435 static bool tegra_drm_file_owns_context(struct tegra_drm_file
*file
,
436 struct tegra_drm_context
*context
)
438 struct tegra_drm_context
*ctx
;
440 list_for_each_entry(ctx
, &file
->contexts
, list
)
447 static int tegra_gem_create(struct drm_device
*drm
, void *data
,
448 struct drm_file
*file
)
450 struct drm_tegra_gem_create
*args
= data
;
453 bo
= tegra_bo_create_with_handle(file
, drm
, args
->size
, args
->flags
,
461 static int tegra_gem_mmap(struct drm_device
*drm
, void *data
,
462 struct drm_file
*file
)
464 struct drm_tegra_gem_mmap
*args
= data
;
465 struct drm_gem_object
*gem
;
468 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
472 bo
= to_tegra_bo(gem
);
474 args
->offset
= drm_vma_node_offset_addr(&bo
->gem
.vma_node
);
476 drm_gem_object_unreference(gem
);
481 static int tegra_syncpt_read(struct drm_device
*drm
, void *data
,
482 struct drm_file
*file
)
484 struct host1x
*host
= dev_get_drvdata(drm
->dev
->parent
);
485 struct drm_tegra_syncpt_read
*args
= data
;
486 struct host1x_syncpt
*sp
;
488 sp
= host1x_syncpt_get(host
, args
->id
);
492 args
->value
= host1x_syncpt_read_min(sp
);
496 static int tegra_syncpt_incr(struct drm_device
*drm
, void *data
,
497 struct drm_file
*file
)
499 struct host1x
*host1x
= dev_get_drvdata(drm
->dev
->parent
);
500 struct drm_tegra_syncpt_incr
*args
= data
;
501 struct host1x_syncpt
*sp
;
503 sp
= host1x_syncpt_get(host1x
, args
->id
);
507 return host1x_syncpt_incr(sp
);
510 static int tegra_syncpt_wait(struct drm_device
*drm
, void *data
,
511 struct drm_file
*file
)
513 struct host1x
*host1x
= dev_get_drvdata(drm
->dev
->parent
);
514 struct drm_tegra_syncpt_wait
*args
= data
;
515 struct host1x_syncpt
*sp
;
517 sp
= host1x_syncpt_get(host1x
, args
->id
);
521 return host1x_syncpt_wait(sp
, args
->thresh
, args
->timeout
,
525 static int tegra_open_channel(struct drm_device
*drm
, void *data
,
526 struct drm_file
*file
)
528 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
529 struct tegra_drm
*tegra
= drm
->dev_private
;
530 struct drm_tegra_open_channel
*args
= data
;
531 struct tegra_drm_context
*context
;
532 struct tegra_drm_client
*client
;
535 context
= kzalloc(sizeof(*context
), GFP_KERNEL
);
539 list_for_each_entry(client
, &tegra
->clients
, list
)
540 if (client
->base
.class == args
->client
) {
541 err
= client
->ops
->open_channel(client
, context
);
545 list_add(&context
->list
, &fpriv
->contexts
);
546 args
->context
= (uintptr_t)context
;
547 context
->client
= client
;
555 static int tegra_close_channel(struct drm_device
*drm
, void *data
,
556 struct drm_file
*file
)
558 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
559 struct drm_tegra_close_channel
*args
= data
;
560 struct tegra_drm_context
*context
;
562 context
= tegra_drm_get_context(args
->context
);
564 if (!tegra_drm_file_owns_context(fpriv
, context
))
567 list_del(&context
->list
);
568 tegra_drm_context_free(context
);
573 static int tegra_get_syncpt(struct drm_device
*drm
, void *data
,
574 struct drm_file
*file
)
576 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
577 struct drm_tegra_get_syncpt
*args
= data
;
578 struct tegra_drm_context
*context
;
579 struct host1x_syncpt
*syncpt
;
581 context
= tegra_drm_get_context(args
->context
);
583 if (!tegra_drm_file_owns_context(fpriv
, context
))
586 if (args
->index
>= context
->client
->base
.num_syncpts
)
589 syncpt
= context
->client
->base
.syncpts
[args
->index
];
590 args
->id
= host1x_syncpt_id(syncpt
);
595 static int tegra_submit(struct drm_device
*drm
, void *data
,
596 struct drm_file
*file
)
598 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
599 struct drm_tegra_submit
*args
= data
;
600 struct tegra_drm_context
*context
;
602 context
= tegra_drm_get_context(args
->context
);
604 if (!tegra_drm_file_owns_context(fpriv
, context
))
607 return context
->client
->ops
->submit(context
, args
, drm
, file
);
610 static int tegra_get_syncpt_base(struct drm_device
*drm
, void *data
,
611 struct drm_file
*file
)
613 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
614 struct drm_tegra_get_syncpt_base
*args
= data
;
615 struct tegra_drm_context
*context
;
616 struct host1x_syncpt_base
*base
;
617 struct host1x_syncpt
*syncpt
;
619 context
= tegra_drm_get_context(args
->context
);
621 if (!tegra_drm_file_owns_context(fpriv
, context
))
624 if (args
->syncpt
>= context
->client
->base
.num_syncpts
)
627 syncpt
= context
->client
->base
.syncpts
[args
->syncpt
];
629 base
= host1x_syncpt_get_base(syncpt
);
633 args
->id
= host1x_syncpt_base_id(base
);
638 static int tegra_gem_set_tiling(struct drm_device
*drm
, void *data
,
639 struct drm_file
*file
)
641 struct drm_tegra_gem_set_tiling
*args
= data
;
642 enum tegra_bo_tiling_mode mode
;
643 struct drm_gem_object
*gem
;
644 unsigned long value
= 0;
647 switch (args
->mode
) {
648 case DRM_TEGRA_GEM_TILING_MODE_PITCH
:
649 mode
= TEGRA_BO_TILING_MODE_PITCH
;
651 if (args
->value
!= 0)
656 case DRM_TEGRA_GEM_TILING_MODE_TILED
:
657 mode
= TEGRA_BO_TILING_MODE_TILED
;
659 if (args
->value
!= 0)
664 case DRM_TEGRA_GEM_TILING_MODE_BLOCK
:
665 mode
= TEGRA_BO_TILING_MODE_BLOCK
;
677 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
681 bo
= to_tegra_bo(gem
);
683 bo
->tiling
.mode
= mode
;
684 bo
->tiling
.value
= value
;
686 drm_gem_object_unreference(gem
);
691 static int tegra_gem_get_tiling(struct drm_device
*drm
, void *data
,
692 struct drm_file
*file
)
694 struct drm_tegra_gem_get_tiling
*args
= data
;
695 struct drm_gem_object
*gem
;
699 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
703 bo
= to_tegra_bo(gem
);
705 switch (bo
->tiling
.mode
) {
706 case TEGRA_BO_TILING_MODE_PITCH
:
707 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_PITCH
;
711 case TEGRA_BO_TILING_MODE_TILED
:
712 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_TILED
;
716 case TEGRA_BO_TILING_MODE_BLOCK
:
717 args
->mode
= DRM_TEGRA_GEM_TILING_MODE_BLOCK
;
718 args
->value
= bo
->tiling
.value
;
726 drm_gem_object_unreference(gem
);
731 static int tegra_gem_set_flags(struct drm_device
*drm
, void *data
,
732 struct drm_file
*file
)
734 struct drm_tegra_gem_set_flags
*args
= data
;
735 struct drm_gem_object
*gem
;
738 if (args
->flags
& ~DRM_TEGRA_GEM_FLAGS
)
741 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
745 bo
= to_tegra_bo(gem
);
748 if (args
->flags
& DRM_TEGRA_GEM_BOTTOM_UP
)
749 bo
->flags
|= TEGRA_BO_BOTTOM_UP
;
751 drm_gem_object_unreference(gem
);
756 static int tegra_gem_get_flags(struct drm_device
*drm
, void *data
,
757 struct drm_file
*file
)
759 struct drm_tegra_gem_get_flags
*args
= data
;
760 struct drm_gem_object
*gem
;
763 gem
= drm_gem_object_lookup(drm
, file
, args
->handle
);
767 bo
= to_tegra_bo(gem
);
770 if (bo
->flags
& TEGRA_BO_BOTTOM_UP
)
771 args
->flags
|= DRM_TEGRA_GEM_BOTTOM_UP
;
773 drm_gem_object_unreference(gem
);
779 static const struct drm_ioctl_desc tegra_drm_ioctls
[] = {
780 #ifdef CONFIG_DRM_TEGRA_STAGING
781 DRM_IOCTL_DEF_DRV(TEGRA_GEM_CREATE
, tegra_gem_create
, DRM_UNLOCKED
),
782 DRM_IOCTL_DEF_DRV(TEGRA_GEM_MMAP
, tegra_gem_mmap
, DRM_UNLOCKED
),
783 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_READ
, tegra_syncpt_read
, DRM_UNLOCKED
),
784 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_INCR
, tegra_syncpt_incr
, DRM_UNLOCKED
),
785 DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_WAIT
, tegra_syncpt_wait
, DRM_UNLOCKED
),
786 DRM_IOCTL_DEF_DRV(TEGRA_OPEN_CHANNEL
, tegra_open_channel
, DRM_UNLOCKED
),
787 DRM_IOCTL_DEF_DRV(TEGRA_CLOSE_CHANNEL
, tegra_close_channel
, DRM_UNLOCKED
),
788 DRM_IOCTL_DEF_DRV(TEGRA_GET_SYNCPT
, tegra_get_syncpt
, DRM_UNLOCKED
),
789 DRM_IOCTL_DEF_DRV(TEGRA_SUBMIT
, tegra_submit
, DRM_UNLOCKED
),
790 DRM_IOCTL_DEF_DRV(TEGRA_GET_SYNCPT_BASE
, tegra_get_syncpt_base
, DRM_UNLOCKED
),
791 DRM_IOCTL_DEF_DRV(TEGRA_GEM_SET_TILING
, tegra_gem_set_tiling
, DRM_UNLOCKED
),
792 DRM_IOCTL_DEF_DRV(TEGRA_GEM_GET_TILING
, tegra_gem_get_tiling
, DRM_UNLOCKED
),
793 DRM_IOCTL_DEF_DRV(TEGRA_GEM_SET_FLAGS
, tegra_gem_set_flags
, DRM_UNLOCKED
),
794 DRM_IOCTL_DEF_DRV(TEGRA_GEM_GET_FLAGS
, tegra_gem_get_flags
, DRM_UNLOCKED
),
798 static const struct file_operations tegra_drm_fops
= {
799 .owner
= THIS_MODULE
,
801 .release
= drm_release
,
802 .unlocked_ioctl
= drm_ioctl
,
803 .mmap
= tegra_drm_mmap
,
807 .compat_ioctl
= drm_compat_ioctl
,
809 .llseek
= noop_llseek
,
812 static struct drm_crtc
*tegra_crtc_from_pipe(struct drm_device
*drm
,
815 struct drm_crtc
*crtc
;
817 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
) {
818 if (pipe
== drm_crtc_index(crtc
))
825 static u32
tegra_drm_get_vblank_counter(struct drm_device
*drm
, int pipe
)
827 struct drm_crtc
*crtc
= tegra_crtc_from_pipe(drm
, pipe
);
828 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
833 return tegra_dc_get_vblank_counter(dc
);
836 static int tegra_drm_enable_vblank(struct drm_device
*drm
, int pipe
)
838 struct drm_crtc
*crtc
= tegra_crtc_from_pipe(drm
, pipe
);
839 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
844 tegra_dc_enable_vblank(dc
);
849 static void tegra_drm_disable_vblank(struct drm_device
*drm
, int pipe
)
851 struct drm_crtc
*crtc
= tegra_crtc_from_pipe(drm
, pipe
);
852 struct tegra_dc
*dc
= to_tegra_dc(crtc
);
855 tegra_dc_disable_vblank(dc
);
858 static void tegra_drm_preclose(struct drm_device
*drm
, struct drm_file
*file
)
860 struct tegra_drm_file
*fpriv
= file
->driver_priv
;
861 struct tegra_drm_context
*context
, *tmp
;
862 struct drm_crtc
*crtc
;
864 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
)
865 tegra_dc_cancel_page_flip(crtc
, file
);
867 list_for_each_entry_safe(context
, tmp
, &fpriv
->contexts
, list
)
868 tegra_drm_context_free(context
);
873 #ifdef CONFIG_DEBUG_FS
874 static int tegra_debugfs_framebuffers(struct seq_file
*s
, void *data
)
876 struct drm_info_node
*node
= (struct drm_info_node
*)s
->private;
877 struct drm_device
*drm
= node
->minor
->dev
;
878 struct drm_framebuffer
*fb
;
880 mutex_lock(&drm
->mode_config
.fb_lock
);
882 list_for_each_entry(fb
, &drm
->mode_config
.fb_list
, head
) {
883 seq_printf(s
, "%3d: user size: %d x %d, depth %d, %d bpp, refcount %d\n",
884 fb
->base
.id
, fb
->width
, fb
->height
, fb
->depth
,
886 atomic_read(&fb
->refcount
.refcount
));
889 mutex_unlock(&drm
->mode_config
.fb_lock
);
894 static int tegra_debugfs_iova(struct seq_file
*s
, void *data
)
896 struct drm_info_node
*node
= (struct drm_info_node
*)s
->private;
897 struct drm_device
*drm
= node
->minor
->dev
;
898 struct tegra_drm
*tegra
= drm
->dev_private
;
900 return drm_mm_dump_table(s
, &tegra
->mm
);
903 static struct drm_info_list tegra_debugfs_list
[] = {
904 { "framebuffers", tegra_debugfs_framebuffers
, 0 },
905 { "iova", tegra_debugfs_iova
, 0 },
908 static int tegra_debugfs_init(struct drm_minor
*minor
)
910 return drm_debugfs_create_files(tegra_debugfs_list
,
911 ARRAY_SIZE(tegra_debugfs_list
),
912 minor
->debugfs_root
, minor
);
915 static void tegra_debugfs_cleanup(struct drm_minor
*minor
)
917 drm_debugfs_remove_files(tegra_debugfs_list
,
918 ARRAY_SIZE(tegra_debugfs_list
), minor
);
922 static struct drm_driver tegra_drm_driver
= {
923 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
| DRIVER_PRIME
,
924 .load
= tegra_drm_load
,
925 .unload
= tegra_drm_unload
,
926 .open
= tegra_drm_open
,
927 .preclose
= tegra_drm_preclose
,
928 .lastclose
= tegra_drm_lastclose
,
930 .get_vblank_counter
= tegra_drm_get_vblank_counter
,
931 .enable_vblank
= tegra_drm_enable_vblank
,
932 .disable_vblank
= tegra_drm_disable_vblank
,
934 #if defined(CONFIG_DEBUG_FS)
935 .debugfs_init
= tegra_debugfs_init
,
936 .debugfs_cleanup
= tegra_debugfs_cleanup
,
939 .gem_free_object
= tegra_bo_free_object
,
940 .gem_vm_ops
= &tegra_bo_vm_ops
,
942 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
943 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
944 .gem_prime_export
= tegra_gem_prime_export
,
945 .gem_prime_import
= tegra_gem_prime_import
,
947 .dumb_create
= tegra_bo_dumb_create
,
948 .dumb_map_offset
= tegra_bo_dumb_map_offset
,
949 .dumb_destroy
= drm_gem_dumb_destroy
,
951 .ioctls
= tegra_drm_ioctls
,
952 .num_ioctls
= ARRAY_SIZE(tegra_drm_ioctls
),
953 .fops
= &tegra_drm_fops
,
958 .major
= DRIVER_MAJOR
,
959 .minor
= DRIVER_MINOR
,
960 .patchlevel
= DRIVER_PATCHLEVEL
,
963 int tegra_drm_register_client(struct tegra_drm
*tegra
,
964 struct tegra_drm_client
*client
)
966 mutex_lock(&tegra
->clients_lock
);
967 list_add_tail(&client
->list
, &tegra
->clients
);
968 mutex_unlock(&tegra
->clients_lock
);
973 int tegra_drm_unregister_client(struct tegra_drm
*tegra
,
974 struct tegra_drm_client
*client
)
976 mutex_lock(&tegra
->clients_lock
);
977 list_del_init(&client
->list
);
978 mutex_unlock(&tegra
->clients_lock
);
983 static int host1x_drm_probe(struct host1x_device
*dev
)
985 struct drm_driver
*driver
= &tegra_drm_driver
;
986 struct drm_device
*drm
;
989 drm
= drm_dev_alloc(driver
, &dev
->dev
);
993 drm_dev_set_unique(drm
, dev_name(&dev
->dev
));
994 dev_set_drvdata(&dev
->dev
, drm
);
996 err
= drm_dev_register(drm
, 0);
1000 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", driver
->name
,
1001 driver
->major
, driver
->minor
, driver
->patchlevel
,
1002 driver
->date
, drm
->primary
->index
);
1011 static int host1x_drm_remove(struct host1x_device
*dev
)
1013 struct drm_device
*drm
= dev_get_drvdata(&dev
->dev
);
1015 drm_dev_unregister(drm
);
1021 #ifdef CONFIG_PM_SLEEP
1022 static int host1x_drm_suspend(struct device
*dev
)
1024 struct drm_device
*drm
= dev_get_drvdata(dev
);
1026 drm_kms_helper_poll_disable(drm
);
1031 static int host1x_drm_resume(struct device
*dev
)
1033 struct drm_device
*drm
= dev_get_drvdata(dev
);
1035 drm_kms_helper_poll_enable(drm
);
1041 static SIMPLE_DEV_PM_OPS(host1x_drm_pm_ops
, host1x_drm_suspend
,
1044 static const struct of_device_id host1x_drm_subdevs
[] = {
1045 { .compatible
= "nvidia,tegra20-dc", },
1046 { .compatible
= "nvidia,tegra20-hdmi", },
1047 { .compatible
= "nvidia,tegra20-gr2d", },
1048 { .compatible
= "nvidia,tegra20-gr3d", },
1049 { .compatible
= "nvidia,tegra30-dc", },
1050 { .compatible
= "nvidia,tegra30-hdmi", },
1051 { .compatible
= "nvidia,tegra30-gr2d", },
1052 { .compatible
= "nvidia,tegra30-gr3d", },
1053 { .compatible
= "nvidia,tegra114-dsi", },
1054 { .compatible
= "nvidia,tegra114-hdmi", },
1055 { .compatible
= "nvidia,tegra114-gr3d", },
1056 { .compatible
= "nvidia,tegra124-dc", },
1057 { .compatible
= "nvidia,tegra124-sor", },
1058 { .compatible
= "nvidia,tegra124-hdmi", },
1059 { .compatible
= "nvidia,tegra124-dsi", },
1060 { .compatible
= "nvidia,tegra210-dc", },
1064 static struct host1x_driver host1x_drm_driver
= {
1067 .pm
= &host1x_drm_pm_ops
,
1069 .probe
= host1x_drm_probe
,
1070 .remove
= host1x_drm_remove
,
1071 .subdevs
= host1x_drm_subdevs
,
1074 static int __init
host1x_drm_init(void)
1078 err
= host1x_driver_register(&host1x_drm_driver
);
1082 err
= platform_driver_register(&tegra_dc_driver
);
1084 goto unregister_host1x
;
1086 err
= platform_driver_register(&tegra_dsi_driver
);
1090 err
= platform_driver_register(&tegra_sor_driver
);
1092 goto unregister_dsi
;
1094 err
= platform_driver_register(&tegra_hdmi_driver
);
1096 goto unregister_sor
;
1098 err
= platform_driver_register(&tegra_dpaux_driver
);
1100 goto unregister_hdmi
;
1102 err
= platform_driver_register(&tegra_gr2d_driver
);
1104 goto unregister_dpaux
;
1106 err
= platform_driver_register(&tegra_gr3d_driver
);
1108 goto unregister_gr2d
;
1113 platform_driver_unregister(&tegra_gr2d_driver
);
1115 platform_driver_unregister(&tegra_dpaux_driver
);
1117 platform_driver_unregister(&tegra_hdmi_driver
);
1119 platform_driver_unregister(&tegra_sor_driver
);
1121 platform_driver_unregister(&tegra_dsi_driver
);
1123 platform_driver_unregister(&tegra_dc_driver
);
1125 host1x_driver_unregister(&host1x_drm_driver
);
1128 module_init(host1x_drm_init
);
1130 static void __exit
host1x_drm_exit(void)
1132 platform_driver_unregister(&tegra_gr3d_driver
);
1133 platform_driver_unregister(&tegra_gr2d_driver
);
1134 platform_driver_unregister(&tegra_dpaux_driver
);
1135 platform_driver_unregister(&tegra_hdmi_driver
);
1136 platform_driver_unregister(&tegra_sor_driver
);
1137 platform_driver_unregister(&tegra_dsi_driver
);
1138 platform_driver_unregister(&tegra_dc_driver
);
1139 host1x_driver_unregister(&host1x_drm_driver
);
1141 module_exit(host1x_drm_exit
);
1143 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
1144 MODULE_DESCRIPTION("NVIDIA Tegra DRM driver");
1145 MODULE_LICENSE("GPL v2");