2 * Copyright (c) 2015 MediaTek Inc.
3 * Author: YT SHEN <yt.shen@mediatek.com>
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.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
16 #include <drm/drm_atomic.h>
17 #include <drm/drm_atomic_helper.h>
18 #include <drm/drm_crtc_helper.h>
19 #include <drm/drm_gem.h>
20 #include <drm/drm_gem_cma_helper.h>
21 #include <drm/drm_of.h>
22 #include <linux/component.h>
23 #include <linux/iommu.h>
24 #include <linux/of_address.h>
25 #include <linux/of_platform.h>
26 #include <linux/pm_runtime.h>
28 #include "mtk_drm_crtc.h"
29 #include "mtk_drm_ddp.h"
30 #include "mtk_drm_ddp_comp.h"
31 #include "mtk_drm_drv.h"
32 #include "mtk_drm_fb.h"
33 #include "mtk_drm_gem.h"
35 #define DRIVER_NAME "mediatek"
36 #define DRIVER_DESC "Mediatek SoC DRM"
37 #define DRIVER_DATE "20150513"
38 #define DRIVER_MAJOR 1
39 #define DRIVER_MINOR 0
41 static void mtk_atomic_schedule(struct mtk_drm_private
*private,
42 struct drm_atomic_state
*state
)
44 private->commit
.state
= state
;
45 schedule_work(&private->commit
.work
);
48 static void mtk_atomic_wait_for_fences(struct drm_atomic_state
*state
)
50 struct drm_plane
*plane
;
51 struct drm_plane_state
*new_plane_state
;
54 for_each_new_plane_in_state(state
, plane
, new_plane_state
, i
)
55 mtk_fb_wait(new_plane_state
->fb
);
58 static void mtk_atomic_complete(struct mtk_drm_private
*private,
59 struct drm_atomic_state
*state
)
61 struct drm_device
*drm
= private->drm
;
63 mtk_atomic_wait_for_fences(state
);
66 * Mediatek drm supports runtime PM, so plane registers cannot be
67 * written when their crtc is disabled.
69 * The comment for drm_atomic_helper_commit states:
70 * For drivers supporting runtime PM the recommended sequence is
72 * drm_atomic_helper_commit_modeset_disables(dev, state);
73 * drm_atomic_helper_commit_modeset_enables(dev, state);
74 * drm_atomic_helper_commit_planes(dev, state,
75 * DRM_PLANE_COMMIT_ACTIVE_ONLY);
77 * See the kerneldoc entries for these three functions for more details.
79 drm_atomic_helper_commit_modeset_disables(drm
, state
);
80 drm_atomic_helper_commit_modeset_enables(drm
, state
);
81 drm_atomic_helper_commit_planes(drm
, state
,
82 DRM_PLANE_COMMIT_ACTIVE_ONLY
);
84 drm_atomic_helper_wait_for_vblanks(drm
, state
);
86 drm_atomic_helper_cleanup_planes(drm
, state
);
87 drm_atomic_state_put(state
);
90 static void mtk_atomic_work(struct work_struct
*work
)
92 struct mtk_drm_private
*private = container_of(work
,
93 struct mtk_drm_private
, commit
.work
);
95 mtk_atomic_complete(private, private->commit
.state
);
98 static int mtk_atomic_commit(struct drm_device
*drm
,
99 struct drm_atomic_state
*state
,
102 struct mtk_drm_private
*private = drm
->dev_private
;
105 ret
= drm_atomic_helper_prepare_planes(drm
, state
);
109 mutex_lock(&private->commit
.lock
);
110 flush_work(&private->commit
.work
);
112 ret
= drm_atomic_helper_swap_state(state
, true);
114 mutex_unlock(&private->commit
.lock
);
115 drm_atomic_helper_cleanup_planes(drm
, state
);
119 drm_atomic_state_get(state
);
121 mtk_atomic_schedule(private, state
);
123 mtk_atomic_complete(private, state
);
125 mutex_unlock(&private->commit
.lock
);
130 static const struct drm_mode_config_funcs mtk_drm_mode_config_funcs
= {
131 .fb_create
= mtk_drm_mode_fb_create
,
132 .atomic_check
= drm_atomic_helper_check
,
133 .atomic_commit
= mtk_atomic_commit
,
136 static const enum mtk_ddp_comp_id mt2701_mtk_ddp_main
[] = {
139 DDP_COMPONENT_COLOR0
,
144 static const enum mtk_ddp_comp_id mt2701_mtk_ddp_ext
[] = {
149 static const enum mtk_ddp_comp_id mt8173_mtk_ddp_main
[] = {
151 DDP_COMPONENT_COLOR0
,
160 static const enum mtk_ddp_comp_id mt8173_mtk_ddp_ext
[] = {
162 DDP_COMPONENT_COLOR1
,
168 static const struct mtk_mmsys_driver_data mt2701_mmsys_driver_data
= {
169 .main_path
= mt2701_mtk_ddp_main
,
170 .main_len
= ARRAY_SIZE(mt2701_mtk_ddp_main
),
171 .ext_path
= mt2701_mtk_ddp_ext
,
172 .ext_len
= ARRAY_SIZE(mt2701_mtk_ddp_ext
),
173 .shadow_register
= true,
176 static const struct mtk_mmsys_driver_data mt8173_mmsys_driver_data
= {
177 .main_path
= mt8173_mtk_ddp_main
,
178 .main_len
= ARRAY_SIZE(mt8173_mtk_ddp_main
),
179 .ext_path
= mt8173_mtk_ddp_ext
,
180 .ext_len
= ARRAY_SIZE(mt8173_mtk_ddp_ext
),
183 static int mtk_drm_kms_init(struct drm_device
*drm
)
185 struct mtk_drm_private
*private = drm
->dev_private
;
186 struct platform_device
*pdev
;
187 struct device_node
*np
;
188 struct device
*dma_dev
;
191 if (!iommu_present(&platform_bus_type
))
192 return -EPROBE_DEFER
;
194 pdev
= of_find_device_by_node(private->mutex_node
);
196 dev_err(drm
->dev
, "Waiting for disp-mutex device %pOF\n",
197 private->mutex_node
);
198 of_node_put(private->mutex_node
);
199 return -EPROBE_DEFER
;
201 private->mutex_dev
= &pdev
->dev
;
203 drm_mode_config_init(drm
);
205 drm
->mode_config
.min_width
= 64;
206 drm
->mode_config
.min_height
= 64;
209 * set max width and height as default value(4096x4096).
210 * this value would be used to check framebuffer size limitation
211 * at drm_mode_addfb().
213 drm
->mode_config
.max_width
= 4096;
214 drm
->mode_config
.max_height
= 4096;
215 drm
->mode_config
.funcs
= &mtk_drm_mode_config_funcs
;
217 ret
= component_bind_all(drm
->dev
, drm
);
219 goto err_config_cleanup
;
222 * We currently support two fixed data streams, each optional,
223 * and each statically assigned to a crtc:
224 * OVL0 -> COLOR0 -> AAL -> OD -> RDMA0 -> UFOE -> DSI0 ...
226 ret
= mtk_drm_crtc_create(drm
, private->data
->main_path
,
227 private->data
->main_len
);
229 goto err_component_unbind
;
230 /* ... and OVL1 -> COLOR1 -> GAMMA -> RDMA1 -> DPI0. */
231 ret
= mtk_drm_crtc_create(drm
, private->data
->ext_path
,
232 private->data
->ext_len
);
234 goto err_component_unbind
;
236 /* Use OVL device for all DMA memory allocations */
237 np
= private->comp_node
[private->data
->main_path
[0]] ?:
238 private->comp_node
[private->data
->ext_path
[0]];
239 pdev
= of_find_device_by_node(np
);
242 dev_err(drm
->dev
, "Need at least one OVL device\n");
243 goto err_component_unbind
;
246 dma_dev
= &pdev
->dev
;
247 private->dma_dev
= dma_dev
;
250 * Configure the DMA segment size to make sure we get contiguous IOVA
251 * when importing PRIME buffers.
253 if (!dma_dev
->dma_parms
) {
254 private->dma_parms_allocated
= true;
256 devm_kzalloc(drm
->dev
, sizeof(*dma_dev
->dma_parms
),
259 if (!dma_dev
->dma_parms
) {
261 goto err_component_unbind
;
264 ret
= dma_set_max_seg_size(dma_dev
, (unsigned int)DMA_BIT_MASK(32));
266 dev_err(dma_dev
, "Failed to set DMA segment size\n");
267 goto err_unset_dma_parms
;
271 * We don't use the drm_irq_install() helpers provided by the DRM
272 * core, so we need to set this manually in order to allow the
273 * DRM_IOCTL_WAIT_VBLANK to operate correctly.
275 drm
->irq_enabled
= true;
276 ret
= drm_vblank_init(drm
, MAX_CRTC
);
278 goto err_unset_dma_parms
;
280 drm_kms_helper_poll_init(drm
);
281 drm_mode_config_reset(drm
);
286 if (private->dma_parms_allocated
)
287 dma_dev
->dma_parms
= NULL
;
288 err_component_unbind
:
289 component_unbind_all(drm
->dev
, drm
);
291 drm_mode_config_cleanup(drm
);
296 static void mtk_drm_kms_deinit(struct drm_device
*drm
)
298 struct mtk_drm_private
*private = drm
->dev_private
;
300 drm_kms_helper_poll_fini(drm
);
301 drm_atomic_helper_shutdown(drm
);
303 if (private->dma_parms_allocated
)
304 private->dma_dev
->dma_parms
= NULL
;
306 component_unbind_all(drm
->dev
, drm
);
307 drm_mode_config_cleanup(drm
);
310 static const struct file_operations mtk_drm_fops
= {
311 .owner
= THIS_MODULE
,
313 .release
= drm_release
,
314 .unlocked_ioctl
= drm_ioctl
,
315 .mmap
= mtk_drm_gem_mmap
,
318 .compat_ioctl
= drm_compat_ioctl
,
322 * We need to override this because the device used to import the memory is
323 * not dev->dev, as drm_gem_prime_import() expects.
325 struct drm_gem_object
*mtk_drm_gem_prime_import(struct drm_device
*dev
,
326 struct dma_buf
*dma_buf
)
328 struct mtk_drm_private
*private = dev
->dev_private
;
330 return drm_gem_prime_import_dev(dev
, dma_buf
, private->dma_dev
);
333 static struct drm_driver mtk_drm_driver
= {
334 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
| DRIVER_PRIME
|
337 .gem_free_object_unlocked
= mtk_drm_gem_free_object
,
338 .gem_vm_ops
= &drm_gem_cma_vm_ops
,
339 .dumb_create
= mtk_drm_gem_dumb_create
,
341 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
342 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
343 .gem_prime_export
= drm_gem_prime_export
,
344 .gem_prime_import
= mtk_drm_gem_prime_import
,
345 .gem_prime_get_sg_table
= mtk_gem_prime_get_sg_table
,
346 .gem_prime_import_sg_table
= mtk_gem_prime_import_sg_table
,
347 .gem_prime_mmap
= mtk_drm_gem_mmap_buf
,
348 .fops
= &mtk_drm_fops
,
353 .major
= DRIVER_MAJOR
,
354 .minor
= DRIVER_MINOR
,
357 static int compare_of(struct device
*dev
, void *data
)
359 return dev
->of_node
== data
;
362 static int mtk_drm_bind(struct device
*dev
)
364 struct mtk_drm_private
*private = dev_get_drvdata(dev
);
365 struct drm_device
*drm
;
368 drm
= drm_dev_alloc(&mtk_drm_driver
, dev
);
372 drm
->dev_private
= private;
375 ret
= mtk_drm_kms_init(drm
);
379 ret
= drm_dev_register(drm
, 0);
386 mtk_drm_kms_deinit(drm
);
392 static void mtk_drm_unbind(struct device
*dev
)
394 struct mtk_drm_private
*private = dev_get_drvdata(dev
);
396 drm_dev_unregister(private->drm
);
397 mtk_drm_kms_deinit(private->drm
);
398 drm_dev_unref(private->drm
);
399 private->num_pipes
= 0;
403 static const struct component_master_ops mtk_drm_ops
= {
404 .bind
= mtk_drm_bind
,
405 .unbind
= mtk_drm_unbind
,
408 static const struct of_device_id mtk_ddp_comp_dt_ids
[] = {
409 { .compatible
= "mediatek,mt2701-disp-ovl", .data
= (void *)MTK_DISP_OVL
},
410 { .compatible
= "mediatek,mt8173-disp-ovl", .data
= (void *)MTK_DISP_OVL
},
411 { .compatible
= "mediatek,mt2701-disp-rdma", .data
= (void *)MTK_DISP_RDMA
},
412 { .compatible
= "mediatek,mt8173-disp-rdma", .data
= (void *)MTK_DISP_RDMA
},
413 { .compatible
= "mediatek,mt8173-disp-wdma", .data
= (void *)MTK_DISP_WDMA
},
414 { .compatible
= "mediatek,mt2701-disp-color", .data
= (void *)MTK_DISP_COLOR
},
415 { .compatible
= "mediatek,mt8173-disp-color", .data
= (void *)MTK_DISP_COLOR
},
416 { .compatible
= "mediatek,mt8173-disp-aal", .data
= (void *)MTK_DISP_AAL
},
417 { .compatible
= "mediatek,mt8173-disp-gamma", .data
= (void *)MTK_DISP_GAMMA
, },
418 { .compatible
= "mediatek,mt8173-disp-ufoe", .data
= (void *)MTK_DISP_UFOE
},
419 { .compatible
= "mediatek,mt2701-dsi", .data
= (void *)MTK_DSI
},
420 { .compatible
= "mediatek,mt8173-dsi", .data
= (void *)MTK_DSI
},
421 { .compatible
= "mediatek,mt8173-dpi", .data
= (void *)MTK_DPI
},
422 { .compatible
= "mediatek,mt2701-disp-mutex", .data
= (void *)MTK_DISP_MUTEX
},
423 { .compatible
= "mediatek,mt8173-disp-mutex", .data
= (void *)MTK_DISP_MUTEX
},
424 { .compatible
= "mediatek,mt2701-disp-pwm", .data
= (void *)MTK_DISP_BLS
},
425 { .compatible
= "mediatek,mt8173-disp-pwm", .data
= (void *)MTK_DISP_PWM
},
426 { .compatible
= "mediatek,mt8173-disp-od", .data
= (void *)MTK_DISP_OD
},
430 static int mtk_drm_probe(struct platform_device
*pdev
)
432 struct device
*dev
= &pdev
->dev
;
433 struct mtk_drm_private
*private;
434 struct resource
*mem
;
435 struct device_node
*node
;
436 struct component_match
*match
= NULL
;
440 private = devm_kzalloc(dev
, sizeof(*private), GFP_KERNEL
);
444 mutex_init(&private->commit
.lock
);
445 INIT_WORK(&private->commit
.work
, mtk_atomic_work
);
446 private->data
= of_device_get_match_data(dev
);
448 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
449 private->config_regs
= devm_ioremap_resource(dev
, mem
);
450 if (IS_ERR(private->config_regs
)) {
451 ret
= PTR_ERR(private->config_regs
);
452 dev_err(dev
, "Failed to ioremap mmsys-config resource: %d\n",
457 /* Iterate over sibling DISP function blocks */
458 for_each_child_of_node(dev
->of_node
->parent
, node
) {
459 const struct of_device_id
*of_id
;
460 enum mtk_ddp_comp_type comp_type
;
463 of_id
= of_match_node(mtk_ddp_comp_dt_ids
, node
);
467 if (!of_device_is_available(node
)) {
468 dev_dbg(dev
, "Skipping disabled component %pOF\n",
473 comp_type
= (enum mtk_ddp_comp_type
)of_id
->data
;
475 if (comp_type
== MTK_DISP_MUTEX
) {
476 private->mutex_node
= of_node_get(node
);
480 comp_id
= mtk_ddp_comp_get_id(node
, comp_type
);
482 dev_warn(dev
, "Skipping unknown component %pOF\n",
487 private->comp_node
[comp_id
] = of_node_get(node
);
490 * Currently only the COLOR, OVL, RDMA, DSI, and DPI blocks have
491 * separate component platform drivers and initialize their own
492 * DDP component structure. The others are initialized here.
494 if (comp_type
== MTK_DISP_COLOR
||
495 comp_type
== MTK_DISP_OVL
||
496 comp_type
== MTK_DISP_RDMA
||
497 comp_type
== MTK_DSI
||
498 comp_type
== MTK_DPI
) {
499 dev_info(dev
, "Adding component match for %pOF\n",
501 drm_of_component_match_add(dev
, &match
, compare_of
,
504 struct mtk_ddp_comp
*comp
;
506 comp
= devm_kzalloc(dev
, sizeof(*comp
), GFP_KERNEL
);
513 ret
= mtk_ddp_comp_init(dev
, node
, comp
, comp_id
, NULL
);
519 private->ddp_comp
[comp_id
] = comp
;
523 if (!private->mutex_node
) {
524 dev_err(dev
, "Failed to find disp-mutex node\n");
529 pm_runtime_enable(dev
);
531 platform_set_drvdata(pdev
, private);
533 ret
= component_master_add_with_match(dev
, &mtk_drm_ops
, match
);
540 pm_runtime_disable(dev
);
542 of_node_put(private->mutex_node
);
543 for (i
= 0; i
< DDP_COMPONENT_ID_MAX
; i
++)
544 of_node_put(private->comp_node
[i
]);
548 static int mtk_drm_remove(struct platform_device
*pdev
)
550 struct mtk_drm_private
*private = platform_get_drvdata(pdev
);
553 component_master_del(&pdev
->dev
, &mtk_drm_ops
);
554 pm_runtime_disable(&pdev
->dev
);
555 of_node_put(private->mutex_node
);
556 for (i
= 0; i
< DDP_COMPONENT_ID_MAX
; i
++)
557 of_node_put(private->comp_node
[i
]);
562 #ifdef CONFIG_PM_SLEEP
563 static int mtk_drm_sys_suspend(struct device
*dev
)
565 struct mtk_drm_private
*private = dev_get_drvdata(dev
);
566 struct drm_device
*drm
= private->drm
;
568 drm_kms_helper_poll_disable(drm
);
570 private->suspend_state
= drm_atomic_helper_suspend(drm
);
571 if (IS_ERR(private->suspend_state
)) {
572 drm_kms_helper_poll_enable(drm
);
573 return PTR_ERR(private->suspend_state
);
576 DRM_DEBUG_DRIVER("mtk_drm_sys_suspend\n");
580 static int mtk_drm_sys_resume(struct device
*dev
)
582 struct mtk_drm_private
*private = dev_get_drvdata(dev
);
583 struct drm_device
*drm
= private->drm
;
585 drm_atomic_helper_resume(drm
, private->suspend_state
);
586 drm_kms_helper_poll_enable(drm
);
588 DRM_DEBUG_DRIVER("mtk_drm_sys_resume\n");
593 static SIMPLE_DEV_PM_OPS(mtk_drm_pm_ops
, mtk_drm_sys_suspend
,
596 static const struct of_device_id mtk_drm_of_ids
[] = {
597 { .compatible
= "mediatek,mt2701-mmsys",
598 .data
= &mt2701_mmsys_driver_data
},
599 { .compatible
= "mediatek,mt8173-mmsys",
600 .data
= &mt8173_mmsys_driver_data
},
604 static struct platform_driver mtk_drm_platform_driver
= {
605 .probe
= mtk_drm_probe
,
606 .remove
= mtk_drm_remove
,
608 .name
= "mediatek-drm",
609 .of_match_table
= mtk_drm_of_ids
,
610 .pm
= &mtk_drm_pm_ops
,
614 static struct platform_driver
* const mtk_drm_drivers
[] = {
616 &mtk_disp_color_driver
,
617 &mtk_disp_ovl_driver
,
618 &mtk_disp_rdma_driver
,
620 &mtk_drm_platform_driver
,
625 static int __init
mtk_drm_init(void)
627 return platform_register_drivers(mtk_drm_drivers
,
628 ARRAY_SIZE(mtk_drm_drivers
));
631 static void __exit
mtk_drm_exit(void)
633 platform_unregister_drivers(mtk_drm_drivers
,
634 ARRAY_SIZE(mtk_drm_drivers
));
637 module_init(mtk_drm_init
);
638 module_exit(mtk_drm_exit
);
640 MODULE_AUTHOR("YT SHEN <yt.shen@mediatek.com>");
641 MODULE_DESCRIPTION("Mediatek SoC DRM driver");
642 MODULE_LICENSE("GPL v2");