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 <drm/drm_of.h>
23 #include <linux/dma-mapping.h>
24 #include <linux/pm_runtime.h>
25 #include <linux/module.h>
26 #include <linux/of_graph.h>
27 #include <linux/component.h>
29 #include "rockchip_drm_drv.h"
30 #include "rockchip_drm_fb.h"
31 #include "rockchip_drm_fbdev.h"
32 #include "rockchip_drm_gem.h"
34 #define DRIVER_NAME "rockchip"
35 #define DRIVER_DESC "RockChip Soc DRM"
36 #define DRIVER_DATE "20140818"
37 #define DRIVER_MAJOR 1
38 #define DRIVER_MINOR 0
41 * Attach a (component) device to the shared drm dma mapping from master drm
42 * device. This is used by the VOPs to map GEM buffers to a common DMA
45 int rockchip_drm_dma_attach_device(struct drm_device
*drm_dev
,
48 struct dma_iommu_mapping
*mapping
= drm_dev
->dev
->archdata
.mapping
;
51 ret
= dma_set_coherent_mask(dev
, DMA_BIT_MASK(32));
55 dma_set_max_seg_size(dev
, DMA_BIT_MASK(32));
57 return arm_iommu_attach_device(dev
, mapping
);
59 EXPORT_SYMBOL_GPL(rockchip_drm_dma_attach_device
);
61 void rockchip_drm_dma_detach_device(struct drm_device
*drm_dev
,
64 arm_iommu_detach_device(dev
);
66 EXPORT_SYMBOL_GPL(rockchip_drm_dma_detach_device
);
68 int rockchip_register_crtc_funcs(struct drm_device
*dev
,
69 const struct rockchip_crtc_funcs
*crtc_funcs
,
72 struct rockchip_drm_private
*priv
= dev
->dev_private
;
74 if (pipe
> ROCKCHIP_MAX_CRTC
)
77 priv
->crtc_funcs
[pipe
] = crtc_funcs
;
81 EXPORT_SYMBOL_GPL(rockchip_register_crtc_funcs
);
83 void rockchip_unregister_crtc_funcs(struct drm_device
*dev
, int pipe
)
85 struct rockchip_drm_private
*priv
= dev
->dev_private
;
87 if (pipe
> ROCKCHIP_MAX_CRTC
)
90 priv
->crtc_funcs
[pipe
] = NULL
;
92 EXPORT_SYMBOL_GPL(rockchip_unregister_crtc_funcs
);
94 static struct drm_crtc
*rockchip_crtc_from_pipe(struct drm_device
*drm
,
97 struct drm_crtc
*crtc
;
100 list_for_each_entry(crtc
, &drm
->mode_config
.crtc_list
, head
)
107 static int rockchip_drm_crtc_enable_vblank(struct drm_device
*dev
,
110 struct rockchip_drm_private
*priv
= dev
->dev_private
;
111 struct drm_crtc
*crtc
= rockchip_crtc_from_pipe(dev
, pipe
);
113 if (crtc
&& priv
->crtc_funcs
[pipe
] &&
114 priv
->crtc_funcs
[pipe
]->enable_vblank
)
115 return priv
->crtc_funcs
[pipe
]->enable_vblank(crtc
);
120 static void rockchip_drm_crtc_disable_vblank(struct drm_device
*dev
,
123 struct rockchip_drm_private
*priv
= dev
->dev_private
;
124 struct drm_crtc
*crtc
= rockchip_crtc_from_pipe(dev
, pipe
);
126 if (crtc
&& priv
->crtc_funcs
[pipe
] &&
127 priv
->crtc_funcs
[pipe
]->enable_vblank
)
128 priv
->crtc_funcs
[pipe
]->disable_vblank(crtc
);
131 static int rockchip_drm_load(struct drm_device
*drm_dev
, unsigned long flags
)
133 struct rockchip_drm_private
*private;
134 struct dma_iommu_mapping
*mapping
;
135 struct device
*dev
= drm_dev
->dev
;
136 struct drm_connector
*connector
;
139 private = devm_kzalloc(drm_dev
->dev
, sizeof(*private), GFP_KERNEL
);
143 drm_dev
->dev_private
= private;
145 drm_mode_config_init(drm_dev
);
147 rockchip_drm_mode_config_init(drm_dev
);
149 dev
->dma_parms
= devm_kzalloc(dev
, sizeof(*dev
->dma_parms
),
151 if (!dev
->dma_parms
) {
153 goto err_config_cleanup
;
156 /* TODO(djkurtz): fetch the mapping start/size from somewhere */
157 mapping
= arm_iommu_create_mapping(&platform_bus_type
, 0x00000000,
159 if (IS_ERR(mapping
)) {
160 ret
= PTR_ERR(mapping
);
161 goto err_config_cleanup
;
164 ret
= dma_set_mask_and_coherent(dev
, DMA_BIT_MASK(32));
166 goto err_release_mapping
;
168 dma_set_max_seg_size(dev
, DMA_BIT_MASK(32));
170 ret
= arm_iommu_attach_device(dev
, mapping
);
172 goto err_release_mapping
;
174 /* Try to bind all sub drivers. */
175 ret
= component_bind_all(dev
, drm_dev
);
177 goto err_detach_device
;
180 * All components are now added, we can publish the connector sysfs
181 * entries to userspace. This will generate hotplug events and so
182 * userspace will expect to be able to access DRM at this point.
184 list_for_each_entry(connector
, &drm_dev
->mode_config
.connector_list
,
186 ret
= drm_connector_register(connector
);
188 dev_err(drm_dev
->dev
,
189 "[CONNECTOR:%d:%s] drm_connector_register failed: %d\n",
191 connector
->name
, ret
);
196 /* init kms poll for handling hpd */
197 drm_kms_helper_poll_init(drm_dev
);
200 * enable drm irq mode.
201 * - with irq_enabled = true, we can use the vblank feature.
203 drm_dev
->irq_enabled
= true;
205 ret
= drm_vblank_init(drm_dev
, ROCKCHIP_MAX_CRTC
);
207 goto err_kms_helper_poll_fini
;
210 * with vblank_disable_allowed = true, vblank interrupt will be disabled
211 * by drm timer once a current process gives up ownership of
212 * vblank event.(after drm_vblank_put function is called)
214 drm_dev
->vblank_disable_allowed
= true;
216 ret
= rockchip_drm_fbdev_init(drm_dev
);
218 goto err_vblank_cleanup
;
222 drm_vblank_cleanup(drm_dev
);
223 err_kms_helper_poll_fini
:
224 drm_kms_helper_poll_fini(drm_dev
);
226 component_unbind_all(dev
, drm_dev
);
228 arm_iommu_detach_device(dev
);
230 arm_iommu_release_mapping(dev
->archdata
.mapping
);
232 drm_mode_config_cleanup(drm_dev
);
233 drm_dev
->dev_private
= NULL
;
237 static int rockchip_drm_unload(struct drm_device
*drm_dev
)
239 struct device
*dev
= drm_dev
->dev
;
241 rockchip_drm_fbdev_fini(drm_dev
);
242 drm_vblank_cleanup(drm_dev
);
243 drm_kms_helper_poll_fini(drm_dev
);
244 component_unbind_all(dev
, drm_dev
);
245 arm_iommu_detach_device(dev
);
246 arm_iommu_release_mapping(dev
->archdata
.mapping
);
247 drm_mode_config_cleanup(drm_dev
);
248 drm_dev
->dev_private
= NULL
;
253 void rockchip_drm_lastclose(struct drm_device
*dev
)
255 struct rockchip_drm_private
*priv
= dev
->dev_private
;
257 drm_fb_helper_restore_fbdev_mode_unlocked(&priv
->fbdev_helper
);
260 static const struct file_operations rockchip_drm_driver_fops
= {
261 .owner
= THIS_MODULE
,
263 .mmap
= rockchip_gem_mmap
,
266 .unlocked_ioctl
= drm_ioctl
,
268 .compat_ioctl
= drm_compat_ioctl
,
270 .release
= drm_release
,
273 const struct vm_operations_struct rockchip_drm_vm_ops
= {
274 .open
= drm_gem_vm_open
,
275 .close
= drm_gem_vm_close
,
278 static struct drm_driver rockchip_drm_driver
= {
279 .driver_features
= DRIVER_MODESET
| DRIVER_GEM
| DRIVER_PRIME
,
280 .load
= rockchip_drm_load
,
281 .unload
= rockchip_drm_unload
,
282 .lastclose
= rockchip_drm_lastclose
,
283 .get_vblank_counter
= drm_vblank_no_hw_counter
,
284 .enable_vblank
= rockchip_drm_crtc_enable_vblank
,
285 .disable_vblank
= rockchip_drm_crtc_disable_vblank
,
286 .gem_vm_ops
= &rockchip_drm_vm_ops
,
287 .gem_free_object
= rockchip_gem_free_object
,
288 .dumb_create
= rockchip_gem_dumb_create
,
289 .dumb_map_offset
= rockchip_gem_dumb_map_offset
,
290 .dumb_destroy
= drm_gem_dumb_destroy
,
291 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
292 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
293 .gem_prime_import
= drm_gem_prime_import
,
294 .gem_prime_export
= drm_gem_prime_export
,
295 .gem_prime_get_sg_table
= rockchip_gem_prime_get_sg_table
,
296 .gem_prime_vmap
= rockchip_gem_prime_vmap
,
297 .gem_prime_vunmap
= rockchip_gem_prime_vunmap
,
298 .gem_prime_mmap
= rockchip_gem_mmap_buf
,
299 .fops
= &rockchip_drm_driver_fops
,
303 .major
= DRIVER_MAJOR
,
304 .minor
= DRIVER_MINOR
,
307 #ifdef CONFIG_PM_SLEEP
308 static int rockchip_drm_sys_suspend(struct device
*dev
)
310 struct drm_device
*drm
= dev_get_drvdata(dev
);
311 struct drm_connector
*connector
;
316 drm_modeset_lock_all(drm
);
317 list_for_each_entry(connector
, &drm
->mode_config
.connector_list
, head
) {
318 int old_dpms
= connector
->dpms
;
320 if (connector
->funcs
->dpms
)
321 connector
->funcs
->dpms(connector
, DRM_MODE_DPMS_OFF
);
323 /* Set the old mode back to the connector for resume */
324 connector
->dpms
= old_dpms
;
326 drm_modeset_unlock_all(drm
);
331 static int rockchip_drm_sys_resume(struct device
*dev
)
333 struct drm_device
*drm
= dev_get_drvdata(dev
);
334 struct drm_connector
*connector
;
335 enum drm_connector_status status
;
336 bool changed
= false;
341 drm_modeset_lock_all(drm
);
342 list_for_each_entry(connector
, &drm
->mode_config
.connector_list
, head
) {
343 int desired_mode
= connector
->dpms
;
346 * at suspend time, we save dpms to connector->dpms,
347 * restore the old_dpms, and at current time, the connector
348 * dpms status must be DRM_MODE_DPMS_OFF.
350 connector
->dpms
= DRM_MODE_DPMS_OFF
;
353 * If the connector has been disconnected during suspend,
354 * disconnect it from the encoder and leave it off. We'll notify
355 * userspace at the end.
357 if (desired_mode
== DRM_MODE_DPMS_ON
) {
358 status
= connector
->funcs
->detect(connector
, true);
359 if (status
== connector_status_disconnected
) {
360 connector
->encoder
= NULL
;
361 connector
->status
= status
;
366 if (connector
->funcs
->dpms
)
367 connector
->funcs
->dpms(connector
, desired_mode
);
369 drm_modeset_unlock_all(drm
);
371 drm_helper_resume_force_mode(drm
);
374 drm_kms_helper_hotplug_event(drm
);
380 static const struct dev_pm_ops rockchip_drm_pm_ops
= {
381 SET_SYSTEM_SLEEP_PM_OPS(rockchip_drm_sys_suspend
,
382 rockchip_drm_sys_resume
)
386 * @node: device tree node containing encoder input ports
387 * @encoder: drm_encoder
389 int rockchip_drm_encoder_get_mux_id(struct device_node
*node
,
390 struct drm_encoder
*encoder
)
392 struct device_node
*ep
;
393 struct drm_crtc
*crtc
= encoder
->crtc
;
394 struct of_endpoint endpoint
;
395 struct device_node
*port
;
401 for_each_endpoint_of_node(node
, ep
) {
402 port
= of_graph_get_remote_port(ep
);
404 if (port
== crtc
->port
) {
405 ret
= of_graph_parse_endpoint(ep
, &endpoint
);
407 return ret
?: endpoint
.id
;
413 EXPORT_SYMBOL_GPL(rockchip_drm_encoder_get_mux_id
);
415 static int compare_of(struct device
*dev
, void *data
)
417 struct device_node
*np
= data
;
419 return dev
->of_node
== np
;
422 static int rockchip_drm_bind(struct device
*dev
)
424 struct drm_device
*drm
;
427 drm
= drm_dev_alloc(&rockchip_drm_driver
, dev
);
431 ret
= drm_dev_set_unique(drm
, "%s", dev_name(dev
));
435 ret
= drm_dev_register(drm
, 0);
439 dev_set_drvdata(dev
, drm
);
448 static void rockchip_drm_unbind(struct device
*dev
)
450 struct drm_device
*drm
= dev_get_drvdata(dev
);
452 drm_dev_unregister(drm
);
454 dev_set_drvdata(dev
, NULL
);
457 static const struct component_master_ops rockchip_drm_ops
= {
458 .bind
= rockchip_drm_bind
,
459 .unbind
= rockchip_drm_unbind
,
462 static int rockchip_drm_platform_probe(struct platform_device
*pdev
)
464 int ret
= drm_of_component_probe(&pdev
->dev
, compare_of
,
467 /* keep compatibility with old code that was returning -ENODEV */
474 static int rockchip_drm_platform_remove(struct platform_device
*pdev
)
476 component_master_del(&pdev
->dev
, &rockchip_drm_ops
);
481 static const struct of_device_id rockchip_drm_dt_ids
[] = {
482 { .compatible
= "rockchip,display-subsystem", },
485 MODULE_DEVICE_TABLE(of
, rockchip_drm_dt_ids
);
487 static struct platform_driver rockchip_drm_platform_driver
= {
488 .probe
= rockchip_drm_platform_probe
,
489 .remove
= rockchip_drm_platform_remove
,
491 .name
= "rockchip-drm",
492 .of_match_table
= rockchip_drm_dt_ids
,
493 .pm
= &rockchip_drm_pm_ops
,
497 module_platform_driver(rockchip_drm_platform_driver
);
499 MODULE_AUTHOR("Mark Yao <mark.yao@rock-chips.com>");
500 MODULE_DESCRIPTION("ROCKCHIP DRM Driver");
501 MODULE_LICENSE("GPL v2");