2 * Freescale i.MX drm driver
4 * Copyright (C) 2011 Sascha Hauer, Pengutronix
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
16 #include <linux/component.h>
17 #include <linux/device.h>
19 #include <linux/module.h>
20 #include <linux/of_graph.h>
21 #include <linux/platform_device.h>
23 #include <drm/drm_fb_helper.h>
24 #include <drm/drm_crtc_helper.h>
25 #include <drm/drm_gem_cma_helper.h>
26 #include <drm/drm_fb_cma_helper.h>
34 struct imx_drm_component
{
35 struct device_node
*of_node
;
36 struct list_head list
;
39 struct imx_drm_device
{
40 struct drm_device
*drm
;
41 struct imx_drm_crtc
*crtc
[MAX_CRTC
];
43 struct drm_fbdev_cma
*fbhelper
;
47 struct drm_crtc
*crtc
;
49 struct imx_drm_crtc_helper_funcs imx_drm_helper_funcs
;
50 struct device_node
*port
;
53 static int legacyfb_depth
= 16;
54 module_param(legacyfb_depth
, int, 0444);
56 int imx_drm_crtc_id(struct imx_drm_crtc
*crtc
)
60 EXPORT_SYMBOL_GPL(imx_drm_crtc_id
);
62 static void imx_drm_driver_lastclose(struct drm_device
*drm
)
64 #if IS_ENABLED(CONFIG_DRM_IMX_FB_HELPER)
65 struct imx_drm_device
*imxdrm
= drm
->dev_private
;
68 drm_fbdev_cma_restore_mode(imxdrm
->fbhelper
);
72 static int imx_drm_driver_unload(struct drm_device
*drm
)
74 #if IS_ENABLED(CONFIG_DRM_IMX_FB_HELPER)
75 struct imx_drm_device
*imxdrm
= drm
->dev_private
;
78 drm_kms_helper_poll_fini(drm
);
80 #if IS_ENABLED(CONFIG_DRM_IMX_FB_HELPER)
82 drm_fbdev_cma_fini(imxdrm
->fbhelper
);
85 component_unbind_all(drm
->dev
, drm
);
87 drm_vblank_cleanup(drm
);
88 drm_mode_config_cleanup(drm
);
93 static struct imx_drm_crtc
*imx_drm_find_crtc(struct drm_crtc
*crtc
)
95 struct imx_drm_device
*imxdrm
= crtc
->dev
->dev_private
;
98 for (i
= 0; i
< MAX_CRTC
; i
++)
99 if (imxdrm
->crtc
[i
] && imxdrm
->crtc
[i
]->crtc
== crtc
)
100 return imxdrm
->crtc
[i
];
105 int imx_drm_panel_format_pins(struct drm_encoder
*encoder
,
106 u32 interface_pix_fmt
, int hsync_pin
, int vsync_pin
)
108 struct imx_drm_crtc_helper_funcs
*helper
;
109 struct imx_drm_crtc
*imx_crtc
;
111 imx_crtc
= imx_drm_find_crtc(encoder
->crtc
);
115 helper
= &imx_crtc
->imx_drm_helper_funcs
;
116 if (helper
->set_interface_pix_fmt
)
117 return helper
->set_interface_pix_fmt(encoder
->crtc
,
118 encoder
->encoder_type
, interface_pix_fmt
,
119 hsync_pin
, vsync_pin
);
122 EXPORT_SYMBOL_GPL(imx_drm_panel_format_pins
);
124 int imx_drm_panel_format(struct drm_encoder
*encoder
, u32 interface_pix_fmt
)
126 return imx_drm_panel_format_pins(encoder
, interface_pix_fmt
, 2, 3);
128 EXPORT_SYMBOL_GPL(imx_drm_panel_format
);
130 int imx_drm_crtc_vblank_get(struct imx_drm_crtc
*imx_drm_crtc
)
132 return drm_vblank_get(imx_drm_crtc
->crtc
->dev
, imx_drm_crtc
->pipe
);
134 EXPORT_SYMBOL_GPL(imx_drm_crtc_vblank_get
);
136 void imx_drm_crtc_vblank_put(struct imx_drm_crtc
*imx_drm_crtc
)
138 drm_vblank_put(imx_drm_crtc
->crtc
->dev
, imx_drm_crtc
->pipe
);
140 EXPORT_SYMBOL_GPL(imx_drm_crtc_vblank_put
);
142 void imx_drm_handle_vblank(struct imx_drm_crtc
*imx_drm_crtc
)
144 drm_handle_vblank(imx_drm_crtc
->crtc
->dev
, imx_drm_crtc
->pipe
);
146 EXPORT_SYMBOL_GPL(imx_drm_handle_vblank
);
148 static int imx_drm_enable_vblank(struct drm_device
*drm
, int crtc
)
150 struct imx_drm_device
*imxdrm
= drm
->dev_private
;
151 struct imx_drm_crtc
*imx_drm_crtc
= imxdrm
->crtc
[crtc
];
157 if (!imx_drm_crtc
->imx_drm_helper_funcs
.enable_vblank
)
160 ret
= imx_drm_crtc
->imx_drm_helper_funcs
.enable_vblank(
166 static void imx_drm_disable_vblank(struct drm_device
*drm
, int crtc
)
168 struct imx_drm_device
*imxdrm
= drm
->dev_private
;
169 struct imx_drm_crtc
*imx_drm_crtc
= imxdrm
->crtc
[crtc
];
174 if (!imx_drm_crtc
->imx_drm_helper_funcs
.disable_vblank
)
177 imx_drm_crtc
->imx_drm_helper_funcs
.disable_vblank(imx_drm_crtc
->crtc
);
180 static void imx_drm_driver_preclose(struct drm_device
*drm
,
181 struct drm_file
*file
)
185 if (!file
->is_master
)
188 for (i
= 0; i
< MAX_CRTC
; i
++)
189 imx_drm_disable_vblank(drm
, i
);
192 static const struct file_operations imx_drm_driver_fops
= {
193 .owner
= THIS_MODULE
,
195 .release
= drm_release
,
196 .unlocked_ioctl
= drm_ioctl
,
197 .mmap
= drm_gem_cma_mmap
,
200 .llseek
= noop_llseek
,
203 int imx_drm_connector_mode_valid(struct drm_connector
*connector
,
204 struct drm_display_mode
*mode
)
208 EXPORT_SYMBOL(imx_drm_connector_mode_valid
);
210 void imx_drm_connector_destroy(struct drm_connector
*connector
)
212 drm_sysfs_connector_remove(connector
);
213 drm_connector_cleanup(connector
);
215 EXPORT_SYMBOL_GPL(imx_drm_connector_destroy
);
217 void imx_drm_encoder_destroy(struct drm_encoder
*encoder
)
219 drm_encoder_cleanup(encoder
);
221 EXPORT_SYMBOL_GPL(imx_drm_encoder_destroy
);
223 static void imx_drm_output_poll_changed(struct drm_device
*drm
)
225 #if IS_ENABLED(CONFIG_DRM_IMX_FB_HELPER)
226 struct imx_drm_device
*imxdrm
= drm
->dev_private
;
228 drm_fbdev_cma_hotplug_event(imxdrm
->fbhelper
);
232 static struct drm_mode_config_funcs imx_drm_mode_config_funcs
= {
233 .fb_create
= drm_fb_cma_create
,
234 .output_poll_changed
= imx_drm_output_poll_changed
,
238 * Main DRM initialisation. This binds, initialises and registers
239 * with DRM the subcomponents of the driver.
241 static int imx_drm_driver_load(struct drm_device
*drm
, unsigned long flags
)
243 struct imx_drm_device
*imxdrm
;
244 struct drm_connector
*connector
;
247 imxdrm
= devm_kzalloc(drm
->dev
, sizeof(*imxdrm
), GFP_KERNEL
);
253 drm
->dev_private
= imxdrm
;
256 * enable drm irq mode.
257 * - with irq_enabled = true, we can use the vblank feature.
259 * P.S. note that we wouldn't use drm irq handler but
260 * just specific driver own one instead because
261 * drm framework supports only one irq handler and
262 * drivers can well take care of their interrupts
264 drm
->irq_enabled
= true;
267 * set max width and height as default value(4096x4096).
268 * this value would be used to check framebuffer size limitation
269 * at drm_mode_addfb().
271 drm
->mode_config
.min_width
= 64;
272 drm
->mode_config
.min_height
= 64;
273 drm
->mode_config
.max_width
= 4096;
274 drm
->mode_config
.max_height
= 4096;
275 drm
->mode_config
.funcs
= &imx_drm_mode_config_funcs
;
277 drm_mode_config_init(drm
);
279 ret
= drm_vblank_init(drm
, MAX_CRTC
);
284 * with vblank_disable_allowed = true, vblank interrupt will be
285 * disabled by drm timer once a current process gives up ownership
286 * of vblank event. (after drm_vblank_put function is called)
288 drm
->vblank_disable_allowed
= true;
290 platform_set_drvdata(drm
->platformdev
, drm
);
292 /* Now try and bind all our sub-components */
293 ret
= component_bind_all(drm
->dev
, drm
);
298 * All components are now added, we can publish the connector sysfs
299 * entries to userspace. This will generate hotplug events and so
300 * userspace will expect to be able to access DRM at this point.
302 list_for_each_entry(connector
, &drm
->mode_config
.connector_list
, head
) {
303 ret
= drm_sysfs_connector_add(connector
);
306 "[CONNECTOR:%d:%s] drm_sysfs_connector_add failed: %d\n",
308 drm_get_connector_name(connector
), ret
);
314 * All components are now initialised, so setup the fb helper.
315 * The fb helper takes copies of key hardware information, so the
316 * crtcs/connectors/encoders must not change after this point.
318 #if IS_ENABLED(CONFIG_DRM_IMX_FB_HELPER)
319 if (legacyfb_depth
!= 16 && legacyfb_depth
!= 32) {
320 dev_warn(drm
->dev
, "Invalid legacyfb_depth. Defaulting to 16bpp\n");
323 imxdrm
->fbhelper
= drm_fbdev_cma_init(drm
, legacyfb_depth
,
324 drm
->mode_config
.num_crtc
, MAX_CRTC
);
325 if (IS_ERR(imxdrm
->fbhelper
)) {
326 ret
= PTR_ERR(imxdrm
->fbhelper
);
327 imxdrm
->fbhelper
= NULL
;
332 drm_kms_helper_poll_init(drm
);
337 component_unbind_all(drm
->dev
, drm
);
339 drm_vblank_cleanup(drm
);
341 drm_mode_config_cleanup(drm
);
347 * imx_drm_add_crtc - add a new crtc
349 int imx_drm_add_crtc(struct drm_device
*drm
, struct drm_crtc
*crtc
,
350 struct imx_drm_crtc
**new_crtc
,
351 const struct imx_drm_crtc_helper_funcs
*imx_drm_helper_funcs
,
352 struct device_node
*port
)
354 struct imx_drm_device
*imxdrm
= drm
->dev_private
;
355 struct imx_drm_crtc
*imx_drm_crtc
;
359 * The vblank arrays are dimensioned by MAX_CRTC - we can't
360 * pass IDs greater than this to those functions.
362 if (imxdrm
->pipes
>= MAX_CRTC
)
365 if (imxdrm
->drm
->open_count
)
368 imx_drm_crtc
= kzalloc(sizeof(*imx_drm_crtc
), GFP_KERNEL
);
372 imx_drm_crtc
->imx_drm_helper_funcs
= *imx_drm_helper_funcs
;
373 imx_drm_crtc
->pipe
= imxdrm
->pipes
++;
374 imx_drm_crtc
->port
= port
;
375 imx_drm_crtc
->crtc
= crtc
;
377 imxdrm
->crtc
[imx_drm_crtc
->pipe
] = imx_drm_crtc
;
379 *new_crtc
= imx_drm_crtc
;
381 ret
= drm_mode_crtc_set_gamma_size(imx_drm_crtc
->crtc
, 256);
385 drm_crtc_helper_add(crtc
,
386 imx_drm_crtc
->imx_drm_helper_funcs
.crtc_helper_funcs
);
388 drm_crtc_init(drm
, crtc
,
389 imx_drm_crtc
->imx_drm_helper_funcs
.crtc_funcs
);
394 imxdrm
->crtc
[imx_drm_crtc
->pipe
] = NULL
;
398 EXPORT_SYMBOL_GPL(imx_drm_add_crtc
);
401 * imx_drm_remove_crtc - remove a crtc
403 int imx_drm_remove_crtc(struct imx_drm_crtc
*imx_drm_crtc
)
405 struct imx_drm_device
*imxdrm
= imx_drm_crtc
->crtc
->dev
->dev_private
;
407 drm_crtc_cleanup(imx_drm_crtc
->crtc
);
409 imxdrm
->crtc
[imx_drm_crtc
->pipe
] = NULL
;
415 EXPORT_SYMBOL_GPL(imx_drm_remove_crtc
);
418 * Find the DRM CRTC possible mask for the connected endpoint.
420 * The encoder possible masks are defined by their position in the
421 * mode_config crtc_list. This means that CRTCs must not be added
422 * or removed once the DRM device has been fully initialised.
424 static uint32_t imx_drm_find_crtc_mask(struct imx_drm_device
*imxdrm
,
425 struct device_node
*endpoint
)
427 struct device_node
*port
;
430 port
= of_graph_get_remote_port(endpoint
);
435 for (i
= 0; i
< MAX_CRTC
; i
++) {
436 struct imx_drm_crtc
*imx_drm_crtc
= imxdrm
->crtc
[i
];
437 if (imx_drm_crtc
&& imx_drm_crtc
->port
== port
)
438 return drm_crtc_mask(imx_drm_crtc
->crtc
);
444 static struct device_node
*imx_drm_of_get_next_endpoint(
445 const struct device_node
*parent
, struct device_node
*prev
)
447 struct device_node
*node
= of_graph_get_next_endpoint(parent
, prev
);
452 int imx_drm_encoder_parse_of(struct drm_device
*drm
,
453 struct drm_encoder
*encoder
, struct device_node
*np
)
455 struct imx_drm_device
*imxdrm
= drm
->dev_private
;
456 struct device_node
*ep
= NULL
;
457 uint32_t crtc_mask
= 0;
463 ep
= imx_drm_of_get_next_endpoint(np
, ep
);
467 mask
= imx_drm_find_crtc_mask(imxdrm
, ep
);
470 * If we failed to find the CRTC(s) which this encoder is
471 * supposed to be connected to, it's because the CRTC has
472 * not been registered yet. Defer probing, and hope that
473 * the required CRTC is added later.
476 return -EPROBE_DEFER
;
486 encoder
->possible_crtcs
= crtc_mask
;
488 /* FIXME: this is the mask of outputs which can clone this output. */
489 encoder
->possible_clones
= ~0;
493 EXPORT_SYMBOL_GPL(imx_drm_encoder_parse_of
);
496 * @node: device tree node containing encoder input ports
497 * @encoder: drm_encoder
499 int imx_drm_encoder_get_mux_id(struct device_node
*node
,
500 struct drm_encoder
*encoder
)
502 struct imx_drm_crtc
*imx_crtc
= imx_drm_find_crtc(encoder
->crtc
);
503 struct device_node
*ep
= NULL
;
504 struct of_endpoint endpoint
;
505 struct device_node
*port
;
508 if (!node
|| !imx_crtc
)
512 ep
= imx_drm_of_get_next_endpoint(node
, ep
);
516 port
= of_graph_get_remote_port(ep
);
518 if (port
== imx_crtc
->port
) {
519 ret
= of_graph_parse_endpoint(ep
, &endpoint
);
520 return ret
? ret
: endpoint
.id
;
526 EXPORT_SYMBOL_GPL(imx_drm_encoder_get_mux_id
);
528 static const struct drm_ioctl_desc imx_drm_ioctls
[] = {
532 static struct drm_driver imx_drm_driver
= {
533 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
| DRIVER_PRIME
,
534 .load
= imx_drm_driver_load
,
535 .unload
= imx_drm_driver_unload
,
536 .lastclose
= imx_drm_driver_lastclose
,
537 .preclose
= imx_drm_driver_preclose
,
538 .gem_free_object
= drm_gem_cma_free_object
,
539 .gem_vm_ops
= &drm_gem_cma_vm_ops
,
540 .dumb_create
= drm_gem_cma_dumb_create
,
541 .dumb_map_offset
= drm_gem_cma_dumb_map_offset
,
542 .dumb_destroy
= drm_gem_dumb_destroy
,
544 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
545 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
546 .gem_prime_import
= drm_gem_prime_import
,
547 .gem_prime_export
= drm_gem_prime_export
,
548 .gem_prime_get_sg_table
= drm_gem_cma_prime_get_sg_table
,
549 .gem_prime_import_sg_table
= drm_gem_cma_prime_import_sg_table
,
550 .gem_prime_vmap
= drm_gem_cma_prime_vmap
,
551 .gem_prime_vunmap
= drm_gem_cma_prime_vunmap
,
552 .gem_prime_mmap
= drm_gem_cma_prime_mmap
,
553 .get_vblank_counter
= drm_vblank_count
,
554 .enable_vblank
= imx_drm_enable_vblank
,
555 .disable_vblank
= imx_drm_disable_vblank
,
556 .ioctls
= imx_drm_ioctls
,
557 .num_ioctls
= ARRAY_SIZE(imx_drm_ioctls
),
558 .fops
= &imx_drm_driver_fops
,
560 .desc
= "i.MX DRM graphics",
567 static int compare_of(struct device
*dev
, void *data
)
569 struct device_node
*np
= data
;
571 /* Special case for LDB, one device for two channels */
572 if (of_node_cmp(np
->name
, "lvds-channel") == 0) {
573 np
= of_get_parent(np
);
577 return dev
->of_node
== np
;
580 static LIST_HEAD(imx_drm_components
);
582 static int imx_drm_add_components(struct device
*master
, struct master
*m
)
584 struct imx_drm_component
*component
;
587 list_for_each_entry(component
, &imx_drm_components
, list
) {
588 ret
= component_master_add_child(m
, compare_of
,
596 static int imx_drm_bind(struct device
*dev
)
598 return drm_platform_init(&imx_drm_driver
, to_platform_device(dev
));
601 static void imx_drm_unbind(struct device
*dev
)
603 drm_put_dev(dev_get_drvdata(dev
));
606 static const struct component_master_ops imx_drm_ops
= {
607 .add_components
= imx_drm_add_components
,
608 .bind
= imx_drm_bind
,
609 .unbind
= imx_drm_unbind
,
612 static struct imx_drm_component
*imx_drm_find_component(struct device
*dev
,
613 struct device_node
*node
)
615 struct imx_drm_component
*component
;
617 list_for_each_entry(component
, &imx_drm_components
, list
)
618 if (component
->of_node
== node
)
624 static int imx_drm_add_component(struct device
*dev
, struct device_node
*node
)
626 struct imx_drm_component
*component
;
628 if (imx_drm_find_component(dev
, node
))
631 component
= devm_kzalloc(dev
, sizeof(*component
), GFP_KERNEL
);
635 component
->of_node
= node
;
636 list_add_tail(&component
->list
, &imx_drm_components
);
641 static int imx_drm_platform_probe(struct platform_device
*pdev
)
643 struct device_node
*ep
, *port
, *remote
;
648 * Bind the IPU display interface ports first, so that
649 * imx_drm_encoder_parse_of called from encoder .bind callbacks
653 port
= of_parse_phandle(pdev
->dev
.of_node
, "ports", i
);
657 ret
= imx_drm_add_component(&pdev
->dev
, port
);
663 dev_err(&pdev
->dev
, "missing 'ports' property\n");
667 /* Then bind all encoders */
669 port
= of_parse_phandle(pdev
->dev
.of_node
, "ports", i
);
673 for_each_child_of_node(port
, ep
) {
674 remote
= of_graph_get_remote_port_parent(ep
);
675 if (!remote
|| !of_device_is_available(remote
)) {
680 ret
= imx_drm_add_component(&pdev
->dev
, remote
);
688 ret
= dma_set_coherent_mask(&pdev
->dev
, DMA_BIT_MASK(32));
692 return component_master_add(&pdev
->dev
, &imx_drm_ops
);
695 static int imx_drm_platform_remove(struct platform_device
*pdev
)
697 component_master_del(&pdev
->dev
, &imx_drm_ops
);
701 static const struct of_device_id imx_drm_dt_ids
[] = {
702 { .compatible
= "fsl,imx-display-subsystem", },
705 MODULE_DEVICE_TABLE(of
, imx_drm_dt_ids
);
707 static struct platform_driver imx_drm_pdrv
= {
708 .probe
= imx_drm_platform_probe
,
709 .remove
= imx_drm_platform_remove
,
711 .owner
= THIS_MODULE
,
713 .of_match_table
= imx_drm_dt_ids
,
716 module_platform_driver(imx_drm_pdrv
);
718 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
719 MODULE_DESCRIPTION("i.MX drm driver core");
720 MODULE_LICENSE("GPL");