1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <drm/drmP.h>
18#include <drm/drm_crtc_helper.h>
19#include <drm/drm_fb_helper.h>
20#include <drm/drm_gem_cma_helper.h>
21#include <drm/drm_of.h>
22#include <linux/dma-mapping.h>
23#include <linux/dma-iommu.h>
24#include <linux/pm_runtime.h>
25#include <linux/module.h>
26#include <linux/of_graph.h>
27#include <linux/component.h>
28#include <linux/console.h>
29#include <linux/iommu.h>
30
31#include "rockchip_drm_drv.h"
32#include "rockchip_drm_fb.h"
33#include "rockchip_drm_fbdev.h"
34#include "rockchip_drm_gem.h"
35
36#define DRIVER_NAME "rockchip"
37#define DRIVER_DESC "RockChip Soc DRM"
38#define DRIVER_DATE "20140818"
39#define DRIVER_MAJOR 1
40#define DRIVER_MINOR 0
41
42static bool is_support_iommu = true;
43static struct drm_driver rockchip_drm_driver;
44
45
46
47
48
49
50int rockchip_drm_dma_attach_device(struct drm_device *drm_dev,
51 struct device *dev)
52{
53 struct rockchip_drm_private *private = drm_dev->dev_private;
54 int ret;
55
56 if (!is_support_iommu)
57 return 0;
58
59 ret = iommu_attach_device(private->domain, dev);
60 if (ret) {
61 dev_err(dev, "Failed to attach iommu device\n");
62 return ret;
63 }
64
65 return 0;
66}
67
68void rockchip_drm_dma_detach_device(struct drm_device *drm_dev,
69 struct device *dev)
70{
71 struct rockchip_drm_private *private = drm_dev->dev_private;
72 struct iommu_domain *domain = private->domain;
73
74 if (!is_support_iommu)
75 return;
76
77 iommu_detach_device(domain, dev);
78}
79
80static int rockchip_drm_init_iommu(struct drm_device *drm_dev)
81{
82 struct rockchip_drm_private *private = drm_dev->dev_private;
83 struct iommu_domain_geometry *geometry;
84 u64 start, end;
85
86 if (!is_support_iommu)
87 return 0;
88
89 private->domain = iommu_domain_alloc(&platform_bus_type);
90 if (!private->domain)
91 return -ENOMEM;
92
93 geometry = &private->domain->geometry;
94 start = geometry->aperture_start;
95 end = geometry->aperture_end;
96
97 DRM_DEBUG("IOMMU context initialized (aperture: %#llx-%#llx)\n",
98 start, end);
99 drm_mm_init(&private->mm, start, end - start + 1);
100 mutex_init(&private->mm_lock);
101
102 return 0;
103}
104
105static void rockchip_iommu_cleanup(struct drm_device *drm_dev)
106{
107 struct rockchip_drm_private *private = drm_dev->dev_private;
108
109 if (!is_support_iommu)
110 return;
111
112 drm_mm_takedown(&private->mm);
113 iommu_domain_free(private->domain);
114}
115
116static int rockchip_drm_bind(struct device *dev)
117{
118 struct drm_device *drm_dev;
119 struct rockchip_drm_private *private;
120 int ret;
121
122 drm_dev = drm_dev_alloc(&rockchip_drm_driver, dev);
123 if (IS_ERR(drm_dev))
124 return PTR_ERR(drm_dev);
125
126 dev_set_drvdata(dev, drm_dev);
127
128 private = devm_kzalloc(drm_dev->dev, sizeof(*private), GFP_KERNEL);
129 if (!private) {
130 ret = -ENOMEM;
131 goto err_free;
132 }
133
134 drm_dev->dev_private = private;
135
136 INIT_LIST_HEAD(&private->psr_list);
137 spin_lock_init(&private->psr_list_lock);
138
139 ret = rockchip_drm_init_iommu(drm_dev);
140 if (ret)
141 goto err_free;
142
143 drm_mode_config_init(drm_dev);
144
145 rockchip_drm_mode_config_init(drm_dev);
146
147
148 ret = component_bind_all(dev, drm_dev);
149 if (ret)
150 goto err_mode_config_cleanup;
151
152 ret = drm_vblank_init(drm_dev, drm_dev->mode_config.num_crtc);
153 if (ret)
154 goto err_unbind_all;
155
156 drm_mode_config_reset(drm_dev);
157
158
159
160
161
162 drm_dev->irq_enabled = true;
163
164
165 drm_kms_helper_poll_init(drm_dev);
166
167 ret = rockchip_drm_fbdev_init(drm_dev);
168 if (ret)
169 goto err_kms_helper_poll_fini;
170
171 ret = drm_dev_register(drm_dev, 0);
172 if (ret)
173 goto err_fbdev_fini;
174
175 return 0;
176err_fbdev_fini:
177 rockchip_drm_fbdev_fini(drm_dev);
178err_kms_helper_poll_fini:
179 drm_kms_helper_poll_fini(drm_dev);
180 drm_vblank_cleanup(drm_dev);
181err_unbind_all:
182 component_unbind_all(dev, drm_dev);
183err_mode_config_cleanup:
184 drm_mode_config_cleanup(drm_dev);
185 rockchip_iommu_cleanup(drm_dev);
186err_free:
187 drm_dev->dev_private = NULL;
188 dev_set_drvdata(dev, NULL);
189 drm_dev_unref(drm_dev);
190 return ret;
191}
192
193static void rockchip_drm_unbind(struct device *dev)
194{
195 struct drm_device *drm_dev = dev_get_drvdata(dev);
196
197 drm_dev_unregister(drm_dev);
198
199 rockchip_drm_fbdev_fini(drm_dev);
200 drm_kms_helper_poll_fini(drm_dev);
201
202 drm_atomic_helper_shutdown(drm_dev);
203 drm_vblank_cleanup(drm_dev);
204 component_unbind_all(dev, drm_dev);
205 drm_mode_config_cleanup(drm_dev);
206 rockchip_iommu_cleanup(drm_dev);
207
208 drm_dev->dev_private = NULL;
209 dev_set_drvdata(dev, NULL);
210 drm_dev_unref(drm_dev);
211}
212
213static void rockchip_drm_lastclose(struct drm_device *dev)
214{
215 struct rockchip_drm_private *priv = dev->dev_private;
216
217 drm_fb_helper_restore_fbdev_mode_unlocked(&priv->fbdev_helper);
218}
219
220static const struct file_operations rockchip_drm_driver_fops = {
221 .owner = THIS_MODULE,
222 .open = drm_open,
223 .mmap = rockchip_gem_mmap,
224 .poll = drm_poll,
225 .read = drm_read,
226 .unlocked_ioctl = drm_ioctl,
227 .compat_ioctl = drm_compat_ioctl,
228 .release = drm_release,
229};
230
231static struct drm_driver rockchip_drm_driver = {
232 .driver_features = DRIVER_MODESET | DRIVER_GEM |
233 DRIVER_PRIME | DRIVER_ATOMIC,
234 .lastclose = rockchip_drm_lastclose,
235 .gem_vm_ops = &drm_gem_cma_vm_ops,
236 .gem_free_object_unlocked = rockchip_gem_free_object,
237 .dumb_create = rockchip_gem_dumb_create,
238 .dumb_map_offset = rockchip_gem_dumb_map_offset,
239 .dumb_destroy = drm_gem_dumb_destroy,
240 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
241 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
242 .gem_prime_import = drm_gem_prime_import,
243 .gem_prime_export = drm_gem_prime_export,
244 .gem_prime_get_sg_table = rockchip_gem_prime_get_sg_table,
245 .gem_prime_vmap = rockchip_gem_prime_vmap,
246 .gem_prime_vunmap = rockchip_gem_prime_vunmap,
247 .gem_prime_mmap = rockchip_gem_mmap_buf,
248 .fops = &rockchip_drm_driver_fops,
249 .name = DRIVER_NAME,
250 .desc = DRIVER_DESC,
251 .date = DRIVER_DATE,
252 .major = DRIVER_MAJOR,
253 .minor = DRIVER_MINOR,
254};
255
256#ifdef CONFIG_PM_SLEEP
257static void rockchip_drm_fb_suspend(struct drm_device *drm)
258{
259 struct rockchip_drm_private *priv = drm->dev_private;
260
261 console_lock();
262 drm_fb_helper_set_suspend(&priv->fbdev_helper, 1);
263 console_unlock();
264}
265
266static void rockchip_drm_fb_resume(struct drm_device *drm)
267{
268 struct rockchip_drm_private *priv = drm->dev_private;
269
270 console_lock();
271 drm_fb_helper_set_suspend(&priv->fbdev_helper, 0);
272 console_unlock();
273}
274
275static int rockchip_drm_sys_suspend(struct device *dev)
276{
277 struct drm_device *drm = dev_get_drvdata(dev);
278 struct rockchip_drm_private *priv = drm->dev_private;
279
280 drm_kms_helper_poll_disable(drm);
281 rockchip_drm_fb_suspend(drm);
282
283 priv->state = drm_atomic_helper_suspend(drm);
284 if (IS_ERR(priv->state)) {
285 rockchip_drm_fb_resume(drm);
286 drm_kms_helper_poll_enable(drm);
287 return PTR_ERR(priv->state);
288 }
289
290 return 0;
291}
292
293static int rockchip_drm_sys_resume(struct device *dev)
294{
295 struct drm_device *drm = dev_get_drvdata(dev);
296 struct rockchip_drm_private *priv = drm->dev_private;
297
298 drm_atomic_helper_resume(drm, priv->state);
299 rockchip_drm_fb_resume(drm);
300 drm_kms_helper_poll_enable(drm);
301
302 return 0;
303}
304#endif
305
306static const struct dev_pm_ops rockchip_drm_pm_ops = {
307 SET_SYSTEM_SLEEP_PM_OPS(rockchip_drm_sys_suspend,
308 rockchip_drm_sys_resume)
309};
310
311#define MAX_ROCKCHIP_SUB_DRIVERS 16
312static struct platform_driver *rockchip_sub_drivers[MAX_ROCKCHIP_SUB_DRIVERS];
313static int num_rockchip_sub_drivers;
314
315static int compare_dev(struct device *dev, void *data)
316{
317 return dev == (struct device *)data;
318}
319
320static struct component_match *rockchip_drm_match_add(struct device *dev)
321{
322 struct component_match *match = NULL;
323 int i;
324
325 for (i = 0; i < num_rockchip_sub_drivers; i++) {
326 struct platform_driver *drv = rockchip_sub_drivers[i];
327 struct device *p = NULL, *d;
328
329 do {
330 d = bus_find_device(&platform_bus_type, p, &drv->driver,
331 (void *)platform_bus_type.match);
332 put_device(p);
333 p = d;
334
335 if (!d)
336 break;
337 component_match_add(dev, &match, compare_dev, d);
338 } while (true);
339 }
340
341 return match ?: ERR_PTR(-ENODEV);
342}
343
344static const struct component_master_ops rockchip_drm_ops = {
345 .bind = rockchip_drm_bind,
346 .unbind = rockchip_drm_unbind,
347};
348
349static int rockchip_drm_platform_of_probe(struct device *dev)
350{
351 struct device_node *np = dev->of_node;
352 struct device_node *port;
353 bool found = false;
354 int i;
355
356 if (!np)
357 return -ENODEV;
358
359 for (i = 0;; i++) {
360 struct device_node *iommu;
361
362 port = of_parse_phandle(np, "ports", i);
363 if (!port)
364 break;
365
366 if (!of_device_is_available(port->parent)) {
367 of_node_put(port);
368 continue;
369 }
370
371 iommu = of_parse_phandle(port->parent, "iommus", 0);
372 if (!iommu || !of_device_is_available(iommu->parent)) {
373 dev_dbg(dev, "no iommu attached for %s, using non-iommu buffers\n",
374 port->parent->full_name);
375
376
377
378
379 is_support_iommu = false;
380 }
381
382 found = true;
383
384 of_node_put(iommu);
385 of_node_put(port);
386 }
387
388 if (i == 0) {
389 dev_err(dev, "missing 'ports' property\n");
390 return -ENODEV;
391 }
392
393 if (!found) {
394 dev_err(dev, "No available vop found for display-subsystem.\n");
395 return -ENODEV;
396 }
397
398 return 0;
399}
400
401static int rockchip_drm_platform_probe(struct platform_device *pdev)
402{
403 struct device *dev = &pdev->dev;
404 struct component_match *match = NULL;
405 int ret;
406
407 ret = rockchip_drm_platform_of_probe(dev);
408 if (ret)
409 return ret;
410
411 match = rockchip_drm_match_add(dev);
412 if (IS_ERR(match))
413 return PTR_ERR(match);
414
415 return component_master_add_with_match(dev, &rockchip_drm_ops, match);
416}
417
418static int rockchip_drm_platform_remove(struct platform_device *pdev)
419{
420 component_master_del(&pdev->dev, &rockchip_drm_ops);
421
422 return 0;
423}
424
425static const struct of_device_id rockchip_drm_dt_ids[] = {
426 { .compatible = "rockchip,display-subsystem", },
427 { },
428};
429MODULE_DEVICE_TABLE(of, rockchip_drm_dt_ids);
430
431static struct platform_driver rockchip_drm_platform_driver = {
432 .probe = rockchip_drm_platform_probe,
433 .remove = rockchip_drm_platform_remove,
434 .driver = {
435 .name = "rockchip-drm",
436 .of_match_table = rockchip_drm_dt_ids,
437 .pm = &rockchip_drm_pm_ops,
438 },
439};
440
441#define ADD_ROCKCHIP_SUB_DRIVER(drv, cond) { \
442 if (IS_ENABLED(cond) && \
443 !WARN_ON(num_rockchip_sub_drivers >= MAX_ROCKCHIP_SUB_DRIVERS)) \
444 rockchip_sub_drivers[num_rockchip_sub_drivers++] = &drv; \
445}
446
447static int __init rockchip_drm_init(void)
448{
449 int ret;
450
451 num_rockchip_sub_drivers = 0;
452 ADD_ROCKCHIP_SUB_DRIVER(vop_platform_driver, CONFIG_DRM_ROCKCHIP);
453 ADD_ROCKCHIP_SUB_DRIVER(rockchip_dp_driver,
454 CONFIG_ROCKCHIP_ANALOGIX_DP);
455 ADD_ROCKCHIP_SUB_DRIVER(cdn_dp_driver, CONFIG_ROCKCHIP_CDN_DP);
456 ADD_ROCKCHIP_SUB_DRIVER(dw_hdmi_rockchip_pltfm_driver,
457 CONFIG_ROCKCHIP_DW_HDMI);
458 ADD_ROCKCHIP_SUB_DRIVER(dw_mipi_dsi_driver,
459 CONFIG_ROCKCHIP_DW_MIPI_DSI);
460 ADD_ROCKCHIP_SUB_DRIVER(inno_hdmi_driver, CONFIG_ROCKCHIP_INNO_HDMI);
461
462 ret = platform_register_drivers(rockchip_sub_drivers,
463 num_rockchip_sub_drivers);
464 if (ret)
465 return ret;
466
467 ret = platform_driver_register(&rockchip_drm_platform_driver);
468 if (ret)
469 goto err_unreg_drivers;
470
471 return 0;
472
473err_unreg_drivers:
474 platform_unregister_drivers(rockchip_sub_drivers,
475 num_rockchip_sub_drivers);
476 return ret;
477}
478
479static void __exit rockchip_drm_fini(void)
480{
481 platform_driver_unregister(&rockchip_drm_platform_driver);
482
483 platform_unregister_drivers(rockchip_sub_drivers,
484 num_rockchip_sub_drivers);
485}
486
487module_init(rockchip_drm_init);
488module_exit(rockchip_drm_fini);
489
490MODULE_AUTHOR("Mark Yao <mark.yao@rock-chips.com>");
491MODULE_DESCRIPTION("ROCKCHIP DRM Driver");
492MODULE_LICENSE("GPL v2");
493
