1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
4 * Author: Rob Clark <rob@ti.com>
7 #include <linux/dma-mapping.h>
8 #include <linux/platform_device.h>
9 #include <linux/sort.h>
10 #include <linux/sys_soc.h>
12 #include <drm/drm_atomic.h>
13 #include <drm/drm_atomic_helper.h>
14 #include <drm/drm_drv.h>
15 #include <drm/drm_fb_helper.h>
16 #include <drm/drm_file.h>
17 #include <drm/drm_ioctl.h>
18 #include <drm/drm_panel.h>
19 #include <drm/drm_prime.h>
20 #include <drm/drm_probe_helper.h>
21 #include <drm/drm_vblank.h>
23 #include "omap_dmm_tiler.h"
26 #define DRIVER_NAME MODULE_NAME
27 #define DRIVER_DESC "OMAP DRM"
28 #define DRIVER_DATE "20110917"
29 #define DRIVER_MAJOR 1
30 #define DRIVER_MINOR 0
31 #define DRIVER_PATCHLEVEL 0
37 /* Notes about mapping DSS and DRM entities:
39 * encoder: manager.. with some extension to allow one primary CRTC
40 * and zero or more video CRTC's to be mapped to one encoder?
41 * connector: dssdev.. manager can be attached/detached from different
45 static void omap_atomic_wait_for_completion(struct drm_device
*dev
,
46 struct drm_atomic_state
*old_state
)
48 struct drm_crtc_state
*new_crtc_state
;
49 struct drm_crtc
*crtc
;
53 for_each_new_crtc_in_state(old_state
, crtc
, new_crtc_state
, i
) {
54 if (!new_crtc_state
->active
)
57 ret
= omap_crtc_wait_pending(crtc
);
61 "atomic complete timeout (pipe %u)!\n", i
);
65 static void omap_atomic_commit_tail(struct drm_atomic_state
*old_state
)
67 struct drm_device
*dev
= old_state
->dev
;
68 struct omap_drm_private
*priv
= dev
->dev_private
;
70 priv
->dispc_ops
->runtime_get(priv
->dispc
);
72 /* Apply the atomic update. */
73 drm_atomic_helper_commit_modeset_disables(dev
, old_state
);
75 if (priv
->omaprev
!= 0x3430) {
76 /* With the current dss dispc implementation we have to enable
77 * the new modeset before we can commit planes. The dispc ovl
78 * configuration relies on the video mode configuration been
79 * written into the HW when the ovl configuration is
82 * This approach is not ideal because after a mode change the
83 * plane update is executed only after the first vblank
84 * interrupt. The dispc implementation should be fixed so that
85 * it is able use uncommitted drm state information.
87 drm_atomic_helper_commit_modeset_enables(dev
, old_state
);
88 omap_atomic_wait_for_completion(dev
, old_state
);
90 drm_atomic_helper_commit_planes(dev
, old_state
, 0);
92 drm_atomic_helper_commit_hw_done(old_state
);
95 * OMAP3 DSS seems to have issues with the work-around above,
96 * resulting in endless sync losts if a crtc is enabled without
97 * a plane. For now, skip the WA for OMAP3.
99 drm_atomic_helper_commit_planes(dev
, old_state
, 0);
101 drm_atomic_helper_commit_modeset_enables(dev
, old_state
);
103 drm_atomic_helper_commit_hw_done(old_state
);
107 * Wait for completion of the page flips to ensure that old buffers
108 * can't be touched by the hardware anymore before cleaning up planes.
110 omap_atomic_wait_for_completion(dev
, old_state
);
112 drm_atomic_helper_cleanup_planes(dev
, old_state
);
114 priv
->dispc_ops
->runtime_put(priv
->dispc
);
117 static const struct drm_mode_config_helper_funcs omap_mode_config_helper_funcs
= {
118 .atomic_commit_tail
= omap_atomic_commit_tail
,
121 static const struct drm_mode_config_funcs omap_mode_config_funcs
= {
122 .fb_create
= omap_framebuffer_create
,
123 .output_poll_changed
= drm_fb_helper_output_poll_changed
,
124 .atomic_check
= drm_atomic_helper_check
,
125 .atomic_commit
= drm_atomic_helper_commit
,
128 static void omap_disconnect_pipelines(struct drm_device
*ddev
)
130 struct omap_drm_private
*priv
= ddev
->dev_private
;
133 for (i
= 0; i
< priv
->num_pipes
; i
++) {
134 struct omap_drm_pipeline
*pipe
= &priv
->pipes
[i
];
136 if (pipe
->output
->panel
)
137 drm_panel_detach(pipe
->output
->panel
);
139 omapdss_device_disconnect(NULL
, pipe
->output
);
141 omapdss_device_put(pipe
->output
);
145 memset(&priv
->channels
, 0, sizeof(priv
->channels
));
150 static int omap_connect_pipelines(struct drm_device
*ddev
)
152 struct omap_drm_private
*priv
= ddev
->dev_private
;
153 struct omap_dss_device
*output
= NULL
;
156 for_each_dss_output(output
) {
157 r
= omapdss_device_connect(priv
->dss
, NULL
, output
);
158 if (r
== -EPROBE_DEFER
) {
159 omapdss_device_put(output
);
162 dev_warn(output
->dev
, "could not connect output %s\n",
165 struct omap_drm_pipeline
*pipe
;
167 pipe
= &priv
->pipes
[priv
->num_pipes
++];
168 pipe
->output
= omapdss_device_get(output
);
170 if (priv
->num_pipes
== ARRAY_SIZE(priv
->pipes
)) {
171 /* To balance the 'for_each_dss_output' loop */
172 omapdss_device_put(output
);
181 static int omap_compare_pipelines(const void *a
, const void *b
)
183 const struct omap_drm_pipeline
*pipe1
= a
;
184 const struct omap_drm_pipeline
*pipe2
= b
;
186 if (pipe1
->alias_id
> pipe2
->alias_id
)
188 else if (pipe1
->alias_id
< pipe2
->alias_id
)
193 static int omap_modeset_init_properties(struct drm_device
*dev
)
195 struct omap_drm_private
*priv
= dev
->dev_private
;
196 unsigned int num_planes
= priv
->dispc_ops
->get_num_ovls(priv
->dispc
);
198 priv
->zorder_prop
= drm_property_create_range(dev
, 0, "zorder", 0,
200 if (!priv
->zorder_prop
)
206 static int omap_display_id(struct omap_dss_device
*output
)
208 struct device_node
*node
= NULL
;
211 struct omap_dss_device
*display
;
213 display
= omapdss_display_get(output
);
214 node
= display
->dev
->of_node
;
215 omapdss_device_put(display
);
216 } else if (output
->bridge
) {
217 struct drm_bridge
*bridge
= output
->bridge
;
220 bridge
= bridge
->next
;
222 node
= bridge
->of_node
;
223 } else if (output
->panel
) {
224 node
= output
->panel
->dev
->of_node
;
227 return node
? of_alias_get_id(node
, "display") : -ENODEV
;
230 static int omap_modeset_init(struct drm_device
*dev
)
232 struct omap_drm_private
*priv
= dev
->dev_private
;
233 int num_ovls
= priv
->dispc_ops
->get_num_ovls(priv
->dispc
);
234 int num_mgrs
= priv
->dispc_ops
->get_num_mgrs(priv
->dispc
);
239 if (!omapdss_stack_is_ready())
240 return -EPROBE_DEFER
;
242 drm_mode_config_init(dev
);
244 ret
= omap_modeset_init_properties(dev
);
249 * This function creates exactly one connector, encoder, crtc,
250 * and primary plane per each connected dss-device. Each
251 * connector->encoder->crtc chain is expected to be separate
252 * and each crtc is connect to a single dss-channel. If the
253 * configuration does not match the expectations or exceeds
254 * the available resources, the configuration is rejected.
256 ret
= omap_connect_pipelines(dev
);
260 if (priv
->num_pipes
> num_mgrs
|| priv
->num_pipes
> num_ovls
) {
261 dev_err(dev
->dev
, "%s(): Too many connected displays\n",
266 /* Create all planes first. They can all be put to any CRTC. */
267 plane_crtc_mask
= (1 << priv
->num_pipes
) - 1;
269 for (i
= 0; i
< num_ovls
; i
++) {
270 enum drm_plane_type type
= i
< priv
->num_pipes
271 ? DRM_PLANE_TYPE_PRIMARY
272 : DRM_PLANE_TYPE_OVERLAY
;
273 struct drm_plane
*plane
;
275 if (WARN_ON(priv
->num_planes
>= ARRAY_SIZE(priv
->planes
)))
278 plane
= omap_plane_init(dev
, i
, type
, plane_crtc_mask
);
280 return PTR_ERR(plane
);
282 priv
->planes
[priv
->num_planes
++] = plane
;
286 * Create the encoders, attach the bridges and get the pipeline alias
289 for (i
= 0; i
< priv
->num_pipes
; i
++) {
290 struct omap_drm_pipeline
*pipe
= &priv
->pipes
[i
];
293 pipe
->encoder
= omap_encoder_init(dev
, pipe
->output
);
297 if (pipe
->output
->bridge
) {
298 ret
= drm_bridge_attach(pipe
->encoder
,
299 pipe
->output
->bridge
, NULL
);
304 id
= omap_display_id(pipe
->output
);
305 pipe
->alias_id
= id
>= 0 ? id
: i
;
308 /* Sort the pipelines by DT aliases. */
309 sort(priv
->pipes
, priv
->num_pipes
, sizeof(priv
->pipes
[0]),
310 omap_compare_pipelines
, NULL
);
313 * Populate the pipeline lookup table by DISPC channel. Only one display
314 * is allowed per channel.
316 for (i
= 0; i
< priv
->num_pipes
; ++i
) {
317 struct omap_drm_pipeline
*pipe
= &priv
->pipes
[i
];
318 enum omap_channel channel
= pipe
->output
->dispc_channel
;
320 if (WARN_ON(priv
->channels
[channel
] != NULL
))
323 priv
->channels
[channel
] = pipe
;
326 /* Create the connectors and CRTCs. */
327 for (i
= 0; i
< priv
->num_pipes
; i
++) {
328 struct omap_drm_pipeline
*pipe
= &priv
->pipes
[i
];
329 struct drm_encoder
*encoder
= pipe
->encoder
;
330 struct drm_crtc
*crtc
;
332 if (!pipe
->output
->bridge
) {
333 pipe
->connector
= omap_connector_init(dev
, pipe
->output
,
335 if (!pipe
->connector
)
338 drm_connector_attach_encoder(pipe
->connector
, encoder
);
340 if (pipe
->output
->panel
) {
341 ret
= drm_panel_attach(pipe
->output
->panel
,
348 crtc
= omap_crtc_init(dev
, pipe
, priv
->planes
[i
]);
350 return PTR_ERR(crtc
);
352 encoder
->possible_crtcs
= 1 << i
;
356 DBG("registered %u planes, %u crtcs/encoders/connectors\n",
357 priv
->num_planes
, priv
->num_pipes
);
359 dev
->mode_config
.min_width
= 8;
360 dev
->mode_config
.min_height
= 2;
363 * Note: these values are used for multiple independent things:
364 * connector mode filtering, buffer sizes, crtc sizes...
365 * Use big enough values here to cover all use cases, and do more
366 * specific checking in the respective code paths.
368 dev
->mode_config
.max_width
= 8192;
369 dev
->mode_config
.max_height
= 8192;
371 /* We want the zpos to be normalized */
372 dev
->mode_config
.normalize_zpos
= true;
374 dev
->mode_config
.funcs
= &omap_mode_config_funcs
;
375 dev
->mode_config
.helper_private
= &omap_mode_config_helper_funcs
;
377 drm_mode_config_reset(dev
);
379 omap_drm_irq_install(dev
);
385 * Enable the HPD in external components if supported
387 static void omap_modeset_enable_external_hpd(struct drm_device
*ddev
)
389 struct omap_drm_private
*priv
= ddev
->dev_private
;
392 for (i
= 0; i
< priv
->num_pipes
; i
++) {
393 if (priv
->pipes
[i
].connector
)
394 omap_connector_enable_hpd(priv
->pipes
[i
].connector
);
399 * Disable the HPD in external components if supported
401 static void omap_modeset_disable_external_hpd(struct drm_device
*ddev
)
403 struct omap_drm_private
*priv
= ddev
->dev_private
;
406 for (i
= 0; i
< priv
->num_pipes
; i
++) {
407 if (priv
->pipes
[i
].connector
)
408 omap_connector_disable_hpd(priv
->pipes
[i
].connector
);
417 static int ioctl_get_param(struct drm_device
*dev
, void *data
,
418 struct drm_file
*file_priv
)
420 struct omap_drm_private
*priv
= dev
->dev_private
;
421 struct drm_omap_param
*args
= data
;
423 DBG("%p: param=%llu", dev
, args
->param
);
425 switch (args
->param
) {
426 case OMAP_PARAM_CHIPSET_ID
:
427 args
->value
= priv
->omaprev
;
430 DBG("unknown parameter %lld", args
->param
);
437 #define OMAP_BO_USER_MASK 0x00ffffff /* flags settable by userspace */
439 static int ioctl_gem_new(struct drm_device
*dev
, void *data
,
440 struct drm_file
*file_priv
)
442 struct drm_omap_gem_new
*args
= data
;
443 u32 flags
= args
->flags
& OMAP_BO_USER_MASK
;
445 VERB("%p:%p: size=0x%08x, flags=%08x", dev
, file_priv
,
446 args
->size
.bytes
, flags
);
448 return omap_gem_new_handle(dev
, file_priv
, args
->size
, flags
,
452 static int ioctl_gem_info(struct drm_device
*dev
, void *data
,
453 struct drm_file
*file_priv
)
455 struct drm_omap_gem_info
*args
= data
;
456 struct drm_gem_object
*obj
;
459 VERB("%p:%p: handle=%d", dev
, file_priv
, args
->handle
);
461 obj
= drm_gem_object_lookup(file_priv
, args
->handle
);
465 args
->size
= omap_gem_mmap_size(obj
);
466 args
->offset
= omap_gem_mmap_offset(obj
);
468 drm_gem_object_put_unlocked(obj
);
473 static const struct drm_ioctl_desc ioctls
[DRM_COMMAND_END
- DRM_COMMAND_BASE
] = {
474 DRM_IOCTL_DEF_DRV(OMAP_GET_PARAM
, ioctl_get_param
,
476 DRM_IOCTL_DEF_DRV(OMAP_SET_PARAM
, drm_invalid_op
,
477 DRM_AUTH
| DRM_MASTER
| DRM_ROOT_ONLY
),
478 DRM_IOCTL_DEF_DRV(OMAP_GEM_NEW
, ioctl_gem_new
,
480 /* Deprecated, to be removed. */
481 DRM_IOCTL_DEF_DRV(OMAP_GEM_CPU_PREP
, drm_noop
,
483 /* Deprecated, to be removed. */
484 DRM_IOCTL_DEF_DRV(OMAP_GEM_CPU_FINI
, drm_noop
,
486 DRM_IOCTL_DEF_DRV(OMAP_GEM_INFO
, ioctl_gem_info
,
494 static int dev_open(struct drm_device
*dev
, struct drm_file
*file
)
496 file
->driver_priv
= NULL
;
498 DBG("open: dev=%p, file=%p", dev
, file
);
503 static const struct vm_operations_struct omap_gem_vm_ops
= {
504 .fault
= omap_gem_fault
,
505 .open
= drm_gem_vm_open
,
506 .close
= drm_gem_vm_close
,
509 static const struct file_operations omapdriver_fops
= {
510 .owner
= THIS_MODULE
,
512 .unlocked_ioctl
= drm_ioctl
,
513 .compat_ioctl
= drm_compat_ioctl
,
514 .release
= drm_release
,
515 .mmap
= omap_gem_mmap
,
518 .llseek
= noop_llseek
,
521 static struct drm_driver omap_drm_driver
= {
522 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
|
523 DRIVER_ATOMIC
| DRIVER_RENDER
,
525 .lastclose
= drm_fb_helper_lastclose
,
526 #ifdef CONFIG_DEBUG_FS
527 .debugfs_init
= omap_debugfs_init
,
529 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
530 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
531 .gem_prime_export
= omap_gem_prime_export
,
532 .gem_prime_import
= omap_gem_prime_import
,
533 .gem_free_object_unlocked
= omap_gem_free_object
,
534 .gem_vm_ops
= &omap_gem_vm_ops
,
535 .dumb_create
= omap_gem_dumb_create
,
536 .dumb_map_offset
= omap_gem_dumb_map_offset
,
538 .num_ioctls
= DRM_OMAP_NUM_IOCTLS
,
539 .fops
= &omapdriver_fops
,
543 .major
= DRIVER_MAJOR
,
544 .minor
= DRIVER_MINOR
,
545 .patchlevel
= DRIVER_PATCHLEVEL
,
548 static const struct soc_device_attribute omapdrm_soc_devices
[] = {
549 { .family
= "OMAP3", .data
= (void *)0x3430 },
550 { .family
= "OMAP4", .data
= (void *)0x4430 },
551 { .family
= "OMAP5", .data
= (void *)0x5430 },
552 { .family
= "DRA7", .data
= (void *)0x0752 },
556 static int omapdrm_init(struct omap_drm_private
*priv
, struct device
*dev
)
558 const struct soc_device_attribute
*soc
;
559 struct drm_device
*ddev
;
563 DBG("%s", dev_name(dev
));
565 /* Allocate and initialize the DRM device. */
566 ddev
= drm_dev_alloc(&omap_drm_driver
, dev
);
568 return PTR_ERR(ddev
);
571 ddev
->dev_private
= priv
;
574 priv
->dss
= omapdss_get_dss();
575 priv
->dispc
= dispc_get_dispc(priv
->dss
);
576 priv
->dispc_ops
= dispc_get_ops(priv
->dss
);
578 omap_crtc_pre_init(priv
);
580 soc
= soc_device_match(omapdrm_soc_devices
);
581 priv
->omaprev
= soc
? (unsigned int)soc
->data
: 0;
582 priv
->wq
= alloc_ordered_workqueue("omapdrm", 0);
584 mutex_init(&priv
->list_lock
);
585 INIT_LIST_HEAD(&priv
->obj_list
);
587 /* Get memory bandwidth limits */
588 if (priv
->dispc_ops
->get_memory_bandwidth_limit
)
589 priv
->max_bandwidth
=
590 priv
->dispc_ops
->get_memory_bandwidth_limit(priv
->dispc
);
594 ret
= omap_modeset_init(ddev
);
596 dev_err(priv
->dev
, "omap_modeset_init failed: ret=%d\n", ret
);
600 /* Initialize vblank handling, start with all CRTCs disabled. */
601 ret
= drm_vblank_init(ddev
, priv
->num_pipes
);
603 dev_err(priv
->dev
, "could not init vblank\n");
604 goto err_cleanup_modeset
;
607 for (i
= 0; i
< priv
->num_pipes
; i
++)
608 drm_crtc_vblank_off(priv
->pipes
[i
].crtc
);
610 omap_fbdev_init(ddev
);
612 drm_kms_helper_poll_init(ddev
);
613 omap_modeset_enable_external_hpd(ddev
);
616 * Register the DRM device with the core and the connectors with
619 ret
= drm_dev_register(ddev
, 0);
621 goto err_cleanup_helpers
;
626 omap_modeset_disable_external_hpd(ddev
);
627 drm_kms_helper_poll_fini(ddev
);
629 omap_fbdev_fini(ddev
);
631 drm_mode_config_cleanup(ddev
);
632 omap_drm_irq_uninstall(ddev
);
634 omap_gem_deinit(ddev
);
635 destroy_workqueue(priv
->wq
);
636 omap_disconnect_pipelines(ddev
);
637 omap_crtc_pre_uninit(priv
);
642 static void omapdrm_cleanup(struct omap_drm_private
*priv
)
644 struct drm_device
*ddev
= priv
->ddev
;
648 drm_dev_unregister(ddev
);
650 omap_modeset_disable_external_hpd(ddev
);
651 drm_kms_helper_poll_fini(ddev
);
653 omap_fbdev_fini(ddev
);
655 drm_atomic_helper_shutdown(ddev
);
657 drm_mode_config_cleanup(ddev
);
659 omap_drm_irq_uninstall(ddev
);
660 omap_gem_deinit(ddev
);
662 destroy_workqueue(priv
->wq
);
664 omap_disconnect_pipelines(ddev
);
665 omap_crtc_pre_uninit(priv
);
670 static int pdev_probe(struct platform_device
*pdev
)
672 struct omap_drm_private
*priv
;
675 if (omapdss_is_initialized() == false)
676 return -EPROBE_DEFER
;
678 ret
= dma_set_coherent_mask(&pdev
->dev
, DMA_BIT_MASK(32));
680 dev_err(&pdev
->dev
, "Failed to set the DMA mask\n");
684 /* Allocate and initialize the driver private structure. */
685 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
689 platform_set_drvdata(pdev
, priv
);
691 ret
= omapdrm_init(priv
, &pdev
->dev
);
698 static int pdev_remove(struct platform_device
*pdev
)
700 struct omap_drm_private
*priv
= platform_get_drvdata(pdev
);
702 omapdrm_cleanup(priv
);
708 #ifdef CONFIG_PM_SLEEP
709 static int omap_drm_suspend(struct device
*dev
)
711 struct omap_drm_private
*priv
= dev_get_drvdata(dev
);
712 struct drm_device
*drm_dev
= priv
->ddev
;
714 return drm_mode_config_helper_suspend(drm_dev
);
717 static int omap_drm_resume(struct device
*dev
)
719 struct omap_drm_private
*priv
= dev_get_drvdata(dev
);
720 struct drm_device
*drm_dev
= priv
->ddev
;
722 drm_mode_config_helper_resume(drm_dev
);
724 return omap_gem_resume(drm_dev
);
728 static SIMPLE_DEV_PM_OPS(omapdrm_pm_ops
, omap_drm_suspend
, omap_drm_resume
);
730 static struct platform_driver pdev
= {
733 .pm
= &omapdrm_pm_ops
,
736 .remove
= pdev_remove
,
739 static struct platform_driver
* const drivers
[] = {
744 static int __init
omap_drm_init(void)
748 return platform_register_drivers(drivers
, ARRAY_SIZE(drivers
));
751 static void __exit
omap_drm_fini(void)
755 platform_unregister_drivers(drivers
, ARRAY_SIZE(drivers
));
758 /* need late_initcall() so we load after dss_driver's are loaded */
759 late_initcall(omap_drm_init
);
760 module_exit(omap_drm_fini
);
762 MODULE_AUTHOR("Rob Clark <rob@ti.com>");
763 MODULE_DESCRIPTION("OMAP DRM Display Driver");
764 MODULE_ALIAS("platform:" DRIVER_NAME
);
765 MODULE_LICENSE("GPL v2");