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/module.h>
25 #include <linux/of_graph.h>
26 #include <linux/component.h>
28 #include "rockchip_drm_drv.h"
29 #include "rockchip_drm_fb.h"
30 #include "rockchip_drm_fbdev.h"
31 #include "rockchip_drm_gem.h"
33 #define DRIVER_NAME "rockchip"
34 #define DRIVER_DESC "RockChip Soc DRM"
35 #define DRIVER_DATE "20140818"
36 #define DRIVER_MAJOR 1
37 #define DRIVER_MINOR 0
40 * Attach a (component) device to the shared drm dma mapping from master drm
41 * device. This is used by the VOPs to map GEM buffers to a common DMA
44 int rockchip_drm_dma_attach_device(struct drm_device
*drm_dev
,
47 struct dma_iommu_mapping
*mapping
= drm_dev
->dev
->archdata
.mapping
;
50 ret
= dma_set_coherent_mask(dev
, DMA_BIT_MASK(32));
54 dma_set_max_seg_size(dev
, DMA_BIT_MASK(32));
56 return arm_iommu_attach_device(dev
, mapping
);
59 void rockchip_drm_dma_detach_device(struct drm_device
*drm_dev
,
62 arm_iommu_detach_device(dev
);
65 int rockchip_register_crtc_funcs(struct drm_crtc
*crtc
,
66 const struct rockchip_crtc_funcs
*crtc_funcs
)
68 int pipe
= drm_crtc_index(crtc
);
69 struct rockchip_drm_private
*priv
= crtc
->dev
->dev_private
;
71 if (pipe
> ROCKCHIP_MAX_CRTC
)
74 priv
->crtc_funcs
[pipe
] = crtc_funcs
;
79 void rockchip_unregister_crtc_funcs(struct drm_crtc
*crtc
)
81 int pipe
= drm_crtc_index(crtc
);
82 struct rockchip_drm_private
*priv
= crtc
->dev
->dev_private
;
84 if (pipe
> ROCKCHIP_MAX_CRTC
)
87 priv
->crtc_funcs
[pipe
] = NULL
;
90 static struct drm_crtc
*rockchip_crtc_from_pipe(struct drm_device
*drm
,
93 struct drm_crtc
*crtc
;
96 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
)
103 static int rockchip_drm_crtc_enable_vblank(struct drm_device
*dev
,
106 struct rockchip_drm_private
*priv
= dev
->dev_private
;
107 struct drm_crtc
*crtc
= rockchip_crtc_from_pipe(dev
, pipe
);
109 if (crtc
&& priv
->crtc_funcs
[pipe
] &&
110 priv
->crtc_funcs
[pipe
]->enable_vblank
)
111 return priv
->crtc_funcs
[pipe
]->enable_vblank(crtc
);
116 static void rockchip_drm_crtc_disable_vblank(struct drm_device
*dev
,
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 mutex_init(&private->commit
.lock
);
140 INIT_WORK(&private->commit
.work
, rockchip_drm_atomic_work
);
142 drm_dev
->dev_private
= private;
144 drm_mode_config_init(drm_dev
);
146 rockchip_drm_mode_config_init(drm_dev
);
148 dev
->dma_parms
= devm_kzalloc(dev
, sizeof(*dev
->dma_parms
),
150 if (!dev
->dma_parms
) {
152 goto err_config_cleanup
;
155 /* TODO(djkurtz): fetch the mapping start/size from somewhere */
156 mapping
= arm_iommu_create_mapping(&platform_bus_type
, 0x00000000,
158 if (IS_ERR(mapping
)) {
159 ret
= PTR_ERR(mapping
);
160 goto err_config_cleanup
;
163 ret
= dma_set_mask_and_coherent(dev
, DMA_BIT_MASK(32));
165 goto err_release_mapping
;
167 dma_set_max_seg_size(dev
, DMA_BIT_MASK(32));
169 ret
= arm_iommu_attach_device(dev
, mapping
);
171 goto err_release_mapping
;
173 /* Try to bind all sub drivers. */
174 ret
= component_bind_all(dev
, drm_dev
);
176 goto err_detach_device
;
179 * All components are now added, we can publish the connector sysfs
180 * entries to userspace. This will generate hotplug events and so
181 * userspace will expect to be able to access DRM at this point.
183 list_for_each_entry(connector
, &drm_dev
->mode_config
.connector_list
,
185 ret
= drm_connector_register(connector
);
187 dev_err(drm_dev
->dev
,
188 "[CONNECTOR:%d:%s] drm_connector_register failed: %d\n",
190 connector
->name
, ret
);
195 /* init kms poll for handling hpd */
196 drm_kms_helper_poll_init(drm_dev
);
199 * enable drm irq mode.
200 * - with irq_enabled = true, we can use the vblank feature.
202 drm_dev
->irq_enabled
= true;
204 ret
= drm_vblank_init(drm_dev
, ROCKCHIP_MAX_CRTC
);
206 goto err_kms_helper_poll_fini
;
209 * with vblank_disable_allowed = true, vblank interrupt will be disabled
210 * by drm timer once a current process gives up ownership of
211 * vblank event.(after drm_vblank_put function is called)
213 drm_dev
->vblank_disable_allowed
= true;
215 drm_mode_config_reset(drm_dev
);
217 ret
= rockchip_drm_fbdev_init(drm_dev
);
219 goto err_vblank_cleanup
;
223 drm_vblank_cleanup(drm_dev
);
224 err_kms_helper_poll_fini
:
225 drm_kms_helper_poll_fini(drm_dev
);
227 component_unbind_all(dev
, drm_dev
);
229 arm_iommu_detach_device(dev
);
231 arm_iommu_release_mapping(dev
->archdata
.mapping
);
233 drm_mode_config_cleanup(drm_dev
);
234 drm_dev
->dev_private
= NULL
;
238 static int rockchip_drm_unload(struct drm_device
*drm_dev
)
240 struct device
*dev
= drm_dev
->dev
;
242 rockchip_drm_fbdev_fini(drm_dev
);
243 drm_vblank_cleanup(drm_dev
);
244 drm_kms_helper_poll_fini(drm_dev
);
245 component_unbind_all(dev
, drm_dev
);
246 arm_iommu_detach_device(dev
);
247 arm_iommu_release_mapping(dev
->archdata
.mapping
);
248 drm_mode_config_cleanup(drm_dev
);
249 drm_dev
->dev_private
= NULL
;
254 void rockchip_drm_lastclose(struct drm_device
*dev
)
256 struct rockchip_drm_private
*priv
= dev
->dev_private
;
258 drm_fb_helper_restore_fbdev_mode_unlocked(&priv
->fbdev_helper
);
261 static const struct file_operations rockchip_drm_driver_fops
= {
262 .owner
= THIS_MODULE
,
264 .mmap
= rockchip_gem_mmap
,
267 .unlocked_ioctl
= drm_ioctl
,
269 .compat_ioctl
= drm_compat_ioctl
,
271 .release
= drm_release
,
274 const struct vm_operations_struct rockchip_drm_vm_ops
= {
275 .open
= drm_gem_vm_open
,
276 .close
= drm_gem_vm_close
,
279 static struct drm_driver rockchip_drm_driver
= {
280 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
|
281 DRIVER_PRIME
| DRIVER_ATOMIC
,
282 .load
= rockchip_drm_load
,
283 .unload
= rockchip_drm_unload
,
284 .lastclose
= rockchip_drm_lastclose
,
285 .get_vblank_counter
= drm_vblank_no_hw_counter
,
286 .enable_vblank
= rockchip_drm_crtc_enable_vblank
,
287 .disable_vblank
= rockchip_drm_crtc_disable_vblank
,
288 .gem_vm_ops
= &rockchip_drm_vm_ops
,
289 .gem_free_object
= rockchip_gem_free_object
,
290 .dumb_create
= rockchip_gem_dumb_create
,
291 .dumb_map_offset
= rockchip_gem_dumb_map_offset
,
292 .dumb_destroy
= drm_gem_dumb_destroy
,
293 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
294 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
295 .gem_prime_import
= drm_gem_prime_import
,
296 .gem_prime_export
= drm_gem_prime_export
,
297 .gem_prime_get_sg_table
= rockchip_gem_prime_get_sg_table
,
298 .gem_prime_vmap
= rockchip_gem_prime_vmap
,
299 .gem_prime_vunmap
= rockchip_gem_prime_vunmap
,
300 .gem_prime_mmap
= rockchip_gem_mmap_buf
,
301 .fops
= &rockchip_drm_driver_fops
,
305 .major
= DRIVER_MAJOR
,
306 .minor
= DRIVER_MINOR
,
309 #ifdef CONFIG_PM_SLEEP
310 static int rockchip_drm_sys_suspend(struct device
*dev
)
312 struct drm_device
*drm
= dev_get_drvdata(dev
);
313 struct drm_connector
*connector
;
318 drm_modeset_lock_all(drm
);
319 list_for_each_entry(connector
, &drm
->mode_config
.connector_list
, head
) {
320 int old_dpms
= connector
->dpms
;
322 if (connector
->funcs
->dpms
)
323 connector
->funcs
->dpms(connector
, DRM_MODE_DPMS_OFF
);
325 /* Set the old mode back to the connector for resume */
326 connector
->dpms
= old_dpms
;
328 drm_modeset_unlock_all(drm
);
333 static int rockchip_drm_sys_resume(struct device
*dev
)
335 struct drm_device
*drm
= dev_get_drvdata(dev
);
336 struct drm_connector
*connector
;
337 enum drm_connector_status status
;
338 bool changed
= false;
343 drm_modeset_lock_all(drm
);
344 list_for_each_entry(connector
, &drm
->mode_config
.connector_list
, head
) {
345 int desired_mode
= connector
->dpms
;
348 * at suspend time, we save dpms to connector->dpms,
349 * restore the old_dpms, and at current time, the connector
350 * dpms status must be DRM_MODE_DPMS_OFF.
352 connector
->dpms
= DRM_MODE_DPMS_OFF
;
355 * If the connector has been disconnected during suspend,
356 * disconnect it from the encoder and leave it off. We'll notify
357 * userspace at the end.
359 if (desired_mode
== DRM_MODE_DPMS_ON
) {
360 status
= connector
->funcs
->detect(connector
, true);
361 if (status
== connector_status_disconnected
) {
362 connector
->encoder
= NULL
;
363 connector
->status
= status
;
368 if (connector
->funcs
->dpms
)
369 connector
->funcs
->dpms(connector
, desired_mode
);
371 drm_modeset_unlock_all(drm
);
373 drm_helper_resume_force_mode(drm
);
376 drm_kms_helper_hotplug_event(drm
);
382 static const struct dev_pm_ops rockchip_drm_pm_ops
= {
383 SET_SYSTEM_SLEEP_PM_OPS(rockchip_drm_sys_suspend
,
384 rockchip_drm_sys_resume
)
388 * @node: device tree node containing encoder input ports
389 * @encoder: drm_encoder
391 int rockchip_drm_encoder_get_mux_id(struct device_node
*node
,
392 struct drm_encoder
*encoder
)
394 struct device_node
*ep
;
395 struct drm_crtc
*crtc
= encoder
->crtc
;
396 struct of_endpoint endpoint
;
397 struct device_node
*port
;
403 for_each_endpoint_of_node(node
, ep
) {
404 port
= of_graph_get_remote_port(ep
);
406 if (port
== crtc
->port
) {
407 ret
= of_graph_parse_endpoint(ep
, &endpoint
);
409 return ret
?: endpoint
.id
;
415 EXPORT_SYMBOL_GPL(rockchip_drm_encoder_get_mux_id
);
417 static int compare_of(struct device
*dev
, void *data
)
419 struct device_node
*np
= data
;
421 return dev
->of_node
== np
;
424 static void rockchip_add_endpoints(struct device
*dev
,
425 struct component_match
**match
,
426 struct device_node
*port
)
428 struct device_node
*ep
, *remote
;
430 for_each_child_of_node(port
, ep
) {
431 remote
= of_graph_get_remote_port_parent(ep
);
432 if (!remote
|| !of_device_is_available(remote
)) {
435 } else if (!of_device_is_available(remote
->parent
)) {
436 dev_warn(dev
, "parent device of %s is not available\n",
442 component_match_add(dev
, match
, compare_of
, remote
);
447 static int rockchip_drm_bind(struct device
*dev
)
449 struct drm_device
*drm
;
452 drm
= drm_dev_alloc(&rockchip_drm_driver
, dev
);
456 ret
= drm_dev_register(drm
, 0);
460 dev_set_drvdata(dev
, drm
);
469 static void rockchip_drm_unbind(struct device
*dev
)
471 struct drm_device
*drm
= dev_get_drvdata(dev
);
473 drm_dev_unregister(drm
);
475 dev_set_drvdata(dev
, NULL
);
478 static const struct component_master_ops rockchip_drm_ops
= {
479 .bind
= rockchip_drm_bind
,
480 .unbind
= rockchip_drm_unbind
,
483 static int rockchip_drm_platform_probe(struct platform_device
*pdev
)
485 struct device
*dev
= &pdev
->dev
;
486 struct component_match
*match
= NULL
;
487 struct device_node
*np
= dev
->of_node
;
488 struct device_node
*port
;
494 * Bind the crtc ports first, so that
495 * drm_of_find_possible_crtcs called from encoder .bind callbacks
499 port
= of_parse_phandle(np
, "ports", i
);
503 if (!of_device_is_available(port
->parent
)) {
508 component_match_add(dev
, &match
, compare_of
, port
->parent
);
513 dev_err(dev
, "missing 'ports' property\n");
518 dev_err(dev
, "No available vop found for display-subsystem.\n");
522 * For each bound crtc, bind the encoders attached to its
526 port
= of_parse_phandle(np
, "ports", i
);
530 if (!of_device_is_available(port
->parent
)) {
535 rockchip_add_endpoints(dev
, &match
, port
);
539 return component_master_add_with_match(dev
, &rockchip_drm_ops
, match
);
542 static int rockchip_drm_platform_remove(struct platform_device
*pdev
)
544 component_master_del(&pdev
->dev
, &rockchip_drm_ops
);
549 static const struct of_device_id rockchip_drm_dt_ids
[] = {
550 { .compatible
= "rockchip,display-subsystem", },
553 MODULE_DEVICE_TABLE(of
, rockchip_drm_dt_ids
);
555 static struct platform_driver rockchip_drm_platform_driver
= {
556 .probe
= rockchip_drm_platform_probe
,
557 .remove
= rockchip_drm_platform_remove
,
559 .name
= "rockchip-drm",
560 .of_match_table
= rockchip_drm_dt_ids
,
561 .pm
= &rockchip_drm_pm_ops
,
565 module_platform_driver(rockchip_drm_platform_driver
);
567 MODULE_AUTHOR("Mark Yao <mark.yao@rock-chips.com>");
568 MODULE_DESCRIPTION("ROCKCHIP DRM Driver");
569 MODULE_LICENSE("GPL v2");