2 * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
3 * Author:Mark Yao <mark.yao@rock-chips.com>
5 * based on exynos_drm_drv.c
7 * This software is licensed under the terms of the GNU General Public
8 * License version 2, as published by the Free Software Foundation, and
9 * may be copied, distributed, and modified under those terms.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
17 #include <asm/dma-iommu.h>
20 #include <drm/drm_crtc_helper.h>
21 #include <drm/drm_fb_helper.h>
22 #include <linux/dma-mapping.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/of_graph.h>
25 #include <linux/component.h>
27 #include "rockchip_drm_drv.h"
28 #include "rockchip_drm_fb.h"
29 #include "rockchip_drm_fbdev.h"
30 #include "rockchip_drm_gem.h"
32 #define DRIVER_NAME "rockchip"
33 #define DRIVER_DESC "RockChip Soc DRM"
34 #define DRIVER_DATE "20140818"
35 #define DRIVER_MAJOR 1
36 #define DRIVER_MINOR 0
39 * Attach a (component) device to the shared drm dma mapping from master drm
40 * device. This is used by the VOPs to map GEM buffers to a common DMA
43 int rockchip_drm_dma_attach_device(struct drm_device
*drm_dev
,
46 struct dma_iommu_mapping
*mapping
= drm_dev
->dev
->archdata
.mapping
;
49 ret
= dma_set_coherent_mask(dev
, DMA_BIT_MASK(32));
53 dma_set_max_seg_size(dev
, DMA_BIT_MASK(32));
55 return arm_iommu_attach_device(dev
, mapping
);
57 EXPORT_SYMBOL_GPL(rockchip_drm_dma_attach_device
);
59 void rockchip_drm_dma_detach_device(struct drm_device
*drm_dev
,
62 arm_iommu_detach_device(dev
);
64 EXPORT_SYMBOL_GPL(rockchip_drm_dma_detach_device
);
66 int rockchip_register_crtc_funcs(struct drm_device
*dev
,
67 const struct rockchip_crtc_funcs
*crtc_funcs
,
70 struct rockchip_drm_private
*priv
= dev
->dev_private
;
72 if (pipe
> ROCKCHIP_MAX_CRTC
)
75 priv
->crtc_funcs
[pipe
] = crtc_funcs
;
79 EXPORT_SYMBOL_GPL(rockchip_register_crtc_funcs
);
81 void rockchip_unregister_crtc_funcs(struct drm_device
*dev
, int pipe
)
83 struct rockchip_drm_private
*priv
= dev
->dev_private
;
85 if (pipe
> ROCKCHIP_MAX_CRTC
)
88 priv
->crtc_funcs
[pipe
] = NULL
;
90 EXPORT_SYMBOL_GPL(rockchip_unregister_crtc_funcs
);
92 static struct drm_crtc
*rockchip_crtc_from_pipe(struct drm_device
*drm
,
95 struct drm_crtc
*crtc
;
98 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
)
105 static int rockchip_drm_crtc_enable_vblank(struct drm_device
*dev
, int pipe
)
107 struct rockchip_drm_private
*priv
= dev
->dev_private
;
108 struct drm_crtc
*crtc
= rockchip_crtc_from_pipe(dev
, pipe
);
110 if (crtc
&& priv
->crtc_funcs
[pipe
] &&
111 priv
->crtc_funcs
[pipe
]->enable_vblank
)
112 return priv
->crtc_funcs
[pipe
]->enable_vblank(crtc
);
117 static void rockchip_drm_crtc_disable_vblank(struct drm_device
*dev
, int pipe
)
119 struct rockchip_drm_private
*priv
= dev
->dev_private
;
120 struct drm_crtc
*crtc
= rockchip_crtc_from_pipe(dev
, pipe
);
122 if (crtc
&& priv
->crtc_funcs
[pipe
] &&
123 priv
->crtc_funcs
[pipe
]->enable_vblank
)
124 priv
->crtc_funcs
[pipe
]->disable_vblank(crtc
);
127 static int rockchip_drm_load(struct drm_device
*drm_dev
, unsigned long flags
)
129 struct rockchip_drm_private
*private;
130 struct dma_iommu_mapping
*mapping
;
131 struct device
*dev
= drm_dev
->dev
;
132 struct drm_connector
*connector
;
135 private = devm_kzalloc(drm_dev
->dev
, sizeof(*private), GFP_KERNEL
);
139 drm_dev
->dev_private
= private;
141 drm_mode_config_init(drm_dev
);
143 rockchip_drm_mode_config_init(drm_dev
);
145 dev
->dma_parms
= devm_kzalloc(dev
, sizeof(*dev
->dma_parms
),
147 if (!dev
->dma_parms
) {
149 goto err_config_cleanup
;
152 /* TODO(djkurtz): fetch the mapping start/size from somewhere */
153 mapping
= arm_iommu_create_mapping(&platform_bus_type
, 0x00000000,
155 if (IS_ERR(mapping
)) {
156 ret
= PTR_ERR(mapping
);
157 goto err_config_cleanup
;
160 ret
= dma_set_mask_and_coherent(dev
, DMA_BIT_MASK(32));
162 goto err_release_mapping
;
164 dma_set_max_seg_size(dev
, DMA_BIT_MASK(32));
166 ret
= arm_iommu_attach_device(dev
, mapping
);
168 goto err_release_mapping
;
170 /* Try to bind all sub drivers. */
171 ret
= component_bind_all(dev
, drm_dev
);
173 goto err_detach_device
;
176 * All components are now added, we can publish the connector sysfs
177 * entries to userspace. This will generate hotplug events and so
178 * userspace will expect to be able to access DRM at this point.
180 list_for_each_entry(connector
, &drm_dev
->mode_config
.connector_list
,
182 ret
= drm_connector_register(connector
);
184 dev_err(drm_dev
->dev
,
185 "[CONNECTOR:%d:%s] drm_connector_register failed: %d\n",
187 connector
->name
, ret
);
192 /* init kms poll for handling hpd */
193 drm_kms_helper_poll_init(drm_dev
);
196 * enable drm irq mode.
197 * - with irq_enabled = true, we can use the vblank feature.
199 drm_dev
->irq_enabled
= true;
201 ret
= drm_vblank_init(drm_dev
, ROCKCHIP_MAX_CRTC
);
203 goto err_kms_helper_poll_fini
;
206 * with vblank_disable_allowed = true, vblank interrupt will be disabled
207 * by drm timer once a current process gives up ownership of
208 * vblank event.(after drm_vblank_put function is called)
210 drm_dev
->vblank_disable_allowed
= true;
212 ret
= rockchip_drm_fbdev_init(drm_dev
);
214 goto err_vblank_cleanup
;
218 drm_vblank_cleanup(drm_dev
);
219 err_kms_helper_poll_fini
:
220 drm_kms_helper_poll_fini(drm_dev
);
222 component_unbind_all(dev
, drm_dev
);
224 arm_iommu_detach_device(dev
);
226 arm_iommu_release_mapping(dev
->archdata
.mapping
);
228 drm_mode_config_cleanup(drm_dev
);
229 drm_dev
->dev_private
= NULL
;
233 static int rockchip_drm_unload(struct drm_device
*drm_dev
)
235 struct device
*dev
= drm_dev
->dev
;
237 rockchip_drm_fbdev_fini(drm_dev
);
238 drm_vblank_cleanup(drm_dev
);
239 drm_kms_helper_poll_fini(drm_dev
);
240 component_unbind_all(dev
, drm_dev
);
241 arm_iommu_detach_device(dev
);
242 arm_iommu_release_mapping(dev
->archdata
.mapping
);
243 drm_mode_config_cleanup(drm_dev
);
244 drm_dev
->dev_private
= NULL
;
249 void rockchip_drm_lastclose(struct drm_device
*dev
)
251 struct rockchip_drm_private
*priv
= dev
->dev_private
;
253 drm_fb_helper_restore_fbdev_mode_unlocked(&priv
->fbdev_helper
);
256 static const struct file_operations rockchip_drm_driver_fops
= {
257 .owner
= THIS_MODULE
,
259 .mmap
= rockchip_gem_mmap
,
262 .unlocked_ioctl
= drm_ioctl
,
264 .compat_ioctl
= drm_compat_ioctl
,
266 .release
= drm_release
,
269 const struct vm_operations_struct rockchip_drm_vm_ops
= {
270 .open
= drm_gem_vm_open
,
271 .close
= drm_gem_vm_close
,
274 static struct drm_driver rockchip_drm_driver
= {
275 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
| DRIVER_PRIME
,
276 .load
= rockchip_drm_load
,
277 .unload
= rockchip_drm_unload
,
278 .lastclose
= rockchip_drm_lastclose
,
279 .get_vblank_counter
= drm_vblank_count
,
280 .enable_vblank
= rockchip_drm_crtc_enable_vblank
,
281 .disable_vblank
= rockchip_drm_crtc_disable_vblank
,
282 .gem_vm_ops
= &rockchip_drm_vm_ops
,
283 .gem_free_object
= rockchip_gem_free_object
,
284 .dumb_create
= rockchip_gem_dumb_create
,
285 .dumb_map_offset
= rockchip_gem_dumb_map_offset
,
286 .dumb_destroy
= drm_gem_dumb_destroy
,
287 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
288 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
289 .gem_prime_import
= drm_gem_prime_import
,
290 .gem_prime_export
= drm_gem_prime_export
,
291 .gem_prime_get_sg_table
= rockchip_gem_prime_get_sg_table
,
292 .gem_prime_vmap
= rockchip_gem_prime_vmap
,
293 .gem_prime_vunmap
= rockchip_gem_prime_vunmap
,
294 .gem_prime_mmap
= rockchip_gem_mmap_buf
,
295 .fops
= &rockchip_drm_driver_fops
,
299 .major
= DRIVER_MAJOR
,
300 .minor
= DRIVER_MINOR
,
303 #ifdef CONFIG_PM_SLEEP
304 static int rockchip_drm_sys_suspend(struct device
*dev
)
306 struct drm_device
*drm
= dev_get_drvdata(dev
);
307 struct drm_connector
*connector
;
312 drm_modeset_lock_all(drm
);
313 list_for_each_entry(connector
, &drm
->mode_config
.connector_list
, head
) {
314 int old_dpms
= connector
->dpms
;
316 if (connector
->funcs
->dpms
)
317 connector
->funcs
->dpms(connector
, DRM_MODE_DPMS_OFF
);
319 /* Set the old mode back to the connector for resume */
320 connector
->dpms
= old_dpms
;
322 drm_modeset_unlock_all(drm
);
327 static int rockchip_drm_sys_resume(struct device
*dev
)
329 struct drm_device
*drm
= dev_get_drvdata(dev
);
330 struct drm_connector
*connector
;
331 enum drm_connector_status status
;
332 bool changed
= false;
337 drm_modeset_lock_all(drm
);
338 list_for_each_entry(connector
, &drm
->mode_config
.connector_list
, head
) {
339 int desired_mode
= connector
->dpms
;
342 * at suspend time, we save dpms to connector->dpms,
343 * restore the old_dpms, and at current time, the connector
344 * dpms status must be DRM_MODE_DPMS_OFF.
346 connector
->dpms
= DRM_MODE_DPMS_OFF
;
349 * If the connector has been disconnected during suspend,
350 * disconnect it from the encoder and leave it off. We'll notify
351 * userspace at the end.
353 if (desired_mode
== DRM_MODE_DPMS_ON
) {
354 status
= connector
->funcs
->detect(connector
, true);
355 if (status
== connector_status_disconnected
) {
356 connector
->encoder
= NULL
;
357 connector
->status
= status
;
362 if (connector
->funcs
->dpms
)
363 connector
->funcs
->dpms(connector
, desired_mode
);
365 drm_modeset_unlock_all(drm
);
367 drm_helper_resume_force_mode(drm
);
370 drm_kms_helper_hotplug_event(drm
);
376 static const struct dev_pm_ops rockchip_drm_pm_ops
= {
377 SET_SYSTEM_SLEEP_PM_OPS(rockchip_drm_sys_suspend
,
378 rockchip_drm_sys_resume
)
382 * @node: device tree node containing encoder input ports
383 * @encoder: drm_encoder
385 int rockchip_drm_encoder_get_mux_id(struct device_node
*node
,
386 struct drm_encoder
*encoder
)
388 struct device_node
*ep
;
389 struct drm_crtc
*crtc
= encoder
->crtc
;
390 struct of_endpoint endpoint
;
391 struct device_node
*port
;
397 for_each_endpoint_of_node(node
, ep
) {
398 port
= of_graph_get_remote_port(ep
);
400 if (port
== crtc
->port
) {
401 ret
= of_graph_parse_endpoint(ep
, &endpoint
);
403 return ret
?: endpoint
.id
;
409 EXPORT_SYMBOL_GPL(rockchip_drm_encoder_get_mux_id
);
411 static int compare_of(struct device
*dev
, void *data
)
413 struct device_node
*np
= data
;
415 return dev
->of_node
== np
;
418 static void rockchip_add_endpoints(struct device
*dev
,
419 struct component_match
**match
,
420 struct device_node
*port
)
422 struct device_node
*ep
, *remote
;
424 for_each_child_of_node(port
, ep
) {
425 remote
= of_graph_get_remote_port_parent(ep
);
426 if (!remote
|| !of_device_is_available(remote
)) {
429 } else if (!of_device_is_available(remote
->parent
)) {
430 dev_warn(dev
, "parent device of %s is not available\n",
436 component_match_add(dev
, match
, compare_of
, remote
);
441 static int rockchip_drm_bind(struct device
*dev
)
443 struct drm_device
*drm
;
446 drm
= drm_dev_alloc(&rockchip_drm_driver
, dev
);
450 ret
= drm_dev_set_unique(drm
, "%s", dev_name(dev
));
454 ret
= drm_dev_register(drm
, 0);
458 dev_set_drvdata(dev
, drm
);
467 static void rockchip_drm_unbind(struct device
*dev
)
469 struct drm_device
*drm
= dev_get_drvdata(dev
);
471 drm_dev_unregister(drm
);
473 dev_set_drvdata(dev
, NULL
);
476 static const struct component_master_ops rockchip_drm_ops
= {
477 .bind
= rockchip_drm_bind
,
478 .unbind
= rockchip_drm_unbind
,
481 static int rockchip_drm_platform_probe(struct platform_device
*pdev
)
483 struct device
*dev
= &pdev
->dev
;
484 struct component_match
*match
= NULL
;
485 struct device_node
*np
= dev
->of_node
;
486 struct device_node
*port
;
492 * Bind the crtc ports first, so that
493 * drm_of_find_possible_crtcs called from encoder .bind callbacks
497 port
= of_parse_phandle(np
, "ports", i
);
501 if (!of_device_is_available(port
->parent
)) {
506 component_match_add(dev
, &match
, compare_of
, port
->parent
);
511 dev_err(dev
, "missing 'ports' property\n");
516 dev_err(dev
, "No available vop found for display-subsystem.\n");
520 * For each bound crtc, bind the encoders attached to its
524 port
= of_parse_phandle(np
, "ports", i
);
528 if (!of_device_is_available(port
->parent
)) {
533 rockchip_add_endpoints(dev
, &match
, port
);
537 return component_master_add_with_match(dev
, &rockchip_drm_ops
, match
);
540 static int rockchip_drm_platform_remove(struct platform_device
*pdev
)
542 component_master_del(&pdev
->dev
, &rockchip_drm_ops
);
547 static const struct of_device_id rockchip_drm_dt_ids
[] = {
548 { .compatible
= "rockchip,display-subsystem", },
551 MODULE_DEVICE_TABLE(of
, rockchip_drm_dt_ids
);
553 static struct platform_driver rockchip_drm_platform_driver
= {
554 .probe
= rockchip_drm_platform_probe
,
555 .remove
= rockchip_drm_platform_remove
,
557 .owner
= THIS_MODULE
,
558 .name
= "rockchip-drm",
559 .of_match_table
= rockchip_drm_dt_ids
,
560 .pm
= &rockchip_drm_pm_ops
,
564 module_platform_driver(rockchip_drm_platform_driver
);
566 MODULE_AUTHOR("Mark Yao <mark.yao@rock-chips.com>");
567 MODULE_DESCRIPTION("ROCKCHIP DRM Driver");
568 MODULE_LICENSE("GPL v2");