1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) Rockchip Electronics Co., Ltd. 4 * Author:Mark Yao <mark.yao@rock-chips.com> 5 * 6 * based on exynos_drm_drv.c 7 */ 8 9 #include <linux/aperture.h> 10 #include <linux/dma-mapping.h> 11 #include <linux/platform_device.h> 12 #include <linux/pm_runtime.h> 13 #include <linux/module.h> 14 #include <linux/of_graph.h> 15 #include <linux/of_platform.h> 16 #include <linux/component.h> 17 #include <linux/console.h> 18 #include <linux/iommu.h> 19 20 #include <drm/clients/drm_client_setup.h> 21 #include <drm/drm_drv.h> 22 #include <drm/drm_fbdev_dma.h> 23 #include <drm/drm_gem_dma_helper.h> 24 #include <drm/drm_of.h> 25 #include <drm/drm_print.h> 26 #include <drm/drm_probe_helper.h> 27 #include <drm/drm_vblank.h> 28 29 #if defined(CONFIG_ARM_DMA_USE_IOMMU) 30 #include <asm/dma-iommu.h> 31 #else 32 #define arm_iommu_detach_device(...) ({ }) 33 #define arm_iommu_release_mapping(...) ({ }) 34 #define to_dma_iommu_mapping(dev) NULL 35 #endif 36 37 #include "rockchip_drm_drv.h" 38 #include "rockchip_drm_fb.h" 39 #include "rockchip_drm_gem.h" 40 41 #define DRIVER_NAME "rockchip" 42 #define DRIVER_DESC "RockChip Soc DRM" 43 #define DRIVER_MAJOR 1 44 #define DRIVER_MINOR 0 45 46 static const struct drm_driver rockchip_drm_driver; 47 48 /* 49 * Attach a (component) device to the shared drm dma mapping from master drm 50 * device. This is used by the VOPs to map GEM buffers to a common DMA 51 * mapping. 52 */ 53 int rockchip_drm_dma_attach_device(struct drm_device *drm_dev, 54 struct device *dev) 55 { 56 struct rockchip_drm_private *private = drm_dev->dev_private; 57 int ret; 58 59 if (!private->domain) 60 return 0; 61 62 if (IS_ENABLED(CONFIG_ARM_DMA_USE_IOMMU)) { 63 struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); 64 65 if (mapping) { 66 arm_iommu_detach_device(dev); 67 arm_iommu_release_mapping(mapping); 68 } 69 } 70 71 ret = iommu_attach_device(private->domain, dev); 72 if (ret) { 73 DRM_DEV_ERROR(dev, "Failed to attach iommu device\n"); 74 return ret; 75 } 76 77 return 0; 78 } 79 80 void rockchip_drm_dma_detach_device(struct drm_device *drm_dev, 81 struct device *dev) 82 { 83 struct rockchip_drm_private *private = drm_dev->dev_private; 84 85 if (!private->domain) 86 return; 87 88 iommu_detach_device(private->domain, dev); 89 } 90 91 void rockchip_drm_dma_init_device(struct drm_device *drm_dev, 92 struct device *dev) 93 { 94 struct rockchip_drm_private *private = drm_dev->dev_private; 95 96 if (!device_iommu_mapped(dev)) 97 private->iommu_dev = ERR_PTR(-ENODEV); 98 else if (!private->iommu_dev) 99 private->iommu_dev = dev; 100 } 101 102 static int rockchip_drm_init_iommu(struct drm_device *drm_dev) 103 { 104 struct rockchip_drm_private *private = drm_dev->dev_private; 105 struct iommu_domain_geometry *geometry; 106 u64 start, end; 107 int ret; 108 109 if (IS_ERR_OR_NULL(private->iommu_dev)) 110 return 0; 111 112 private->domain = iommu_paging_domain_alloc(private->iommu_dev); 113 if (IS_ERR(private->domain)) { 114 ret = PTR_ERR(private->domain); 115 private->domain = NULL; 116 return ret; 117 } 118 119 geometry = &private->domain->geometry; 120 start = geometry->aperture_start; 121 end = geometry->aperture_end; 122 123 DRM_DEBUG("IOMMU context initialized (aperture: %#llx-%#llx)\n", 124 start, end); 125 drm_mm_init(&private->mm, start, end - start + 1); 126 mutex_init(&private->mm_lock); 127 128 return 0; 129 } 130 131 static void rockchip_iommu_cleanup(struct drm_device *drm_dev) 132 { 133 struct rockchip_drm_private *private = drm_dev->dev_private; 134 135 if (!private->domain) 136 return; 137 138 drm_mm_takedown(&private->mm); 139 iommu_domain_free(private->domain); 140 } 141 142 static int rockchip_drm_bind(struct device *dev) 143 { 144 struct drm_device *drm_dev; 145 struct rockchip_drm_private *private; 146 int ret; 147 148 /* Remove existing drivers that may own the framebuffer memory. */ 149 ret = aperture_remove_all_conflicting_devices(rockchip_drm_driver.name); 150 if (ret) { 151 DRM_DEV_ERROR(dev, 152 "Failed to remove existing framebuffers - %d.\n", 153 ret); 154 return ret; 155 } 156 157 drm_dev = drm_dev_alloc(&rockchip_drm_driver, dev); 158 if (IS_ERR(drm_dev)) 159 return PTR_ERR(drm_dev); 160 161 dev_set_drvdata(dev, drm_dev); 162 163 private = devm_kzalloc(drm_dev->dev, sizeof(*private), GFP_KERNEL); 164 if (!private) { 165 ret = -ENOMEM; 166 goto err_free; 167 } 168 169 drm_dev->dev_private = private; 170 171 ret = drmm_mode_config_init(drm_dev); 172 if (ret) 173 goto err_free; 174 175 rockchip_drm_mode_config_init(drm_dev); 176 177 /* Try to bind all sub drivers. */ 178 ret = component_bind_all(dev, drm_dev); 179 if (ret) 180 goto err_free; 181 182 ret = rockchip_drm_init_iommu(drm_dev); 183 if (ret) 184 goto err_unbind_all; 185 186 ret = drm_vblank_init(drm_dev, drm_dev->mode_config.num_crtc); 187 if (ret) 188 goto err_iommu_cleanup; 189 190 drm_mode_config_reset(drm_dev); 191 192 /* init kms poll for handling hpd */ 193 drm_kms_helper_poll_init(drm_dev); 194 195 ret = drm_dev_register(drm_dev, 0); 196 if (ret) 197 goto err_kms_helper_poll_fini; 198 199 drm_client_setup(drm_dev, NULL); 200 201 return 0; 202 err_kms_helper_poll_fini: 203 drm_kms_helper_poll_fini(drm_dev); 204 err_iommu_cleanup: 205 rockchip_iommu_cleanup(drm_dev); 206 err_unbind_all: 207 component_unbind_all(dev, drm_dev); 208 err_free: 209 drm_dev_put(drm_dev); 210 return ret; 211 } 212 213 static void rockchip_drm_unbind(struct device *dev) 214 { 215 struct drm_device *drm_dev = dev_get_drvdata(dev); 216 217 drm_dev_unregister(drm_dev); 218 219 drm_kms_helper_poll_fini(drm_dev); 220 221 drm_atomic_helper_shutdown(drm_dev); 222 component_unbind_all(dev, drm_dev); 223 rockchip_iommu_cleanup(drm_dev); 224 225 drm_dev_put(drm_dev); 226 } 227 228 DEFINE_DRM_GEM_FOPS(rockchip_drm_driver_fops); 229 230 static const struct drm_driver rockchip_drm_driver = { 231 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC, 232 .dumb_create = rockchip_gem_dumb_create, 233 .gem_prime_import_sg_table = rockchip_gem_prime_import_sg_table, 234 DRM_FBDEV_DMA_DRIVER_OPS, 235 .fops = &rockchip_drm_driver_fops, 236 .name = DRIVER_NAME, 237 .desc = DRIVER_DESC, 238 .major = DRIVER_MAJOR, 239 .minor = DRIVER_MINOR, 240 }; 241 242 #ifdef CONFIG_PM_SLEEP 243 static int rockchip_drm_sys_suspend(struct device *dev) 244 { 245 struct drm_device *drm = dev_get_drvdata(dev); 246 247 return drm_mode_config_helper_suspend(drm); 248 } 249 250 static int rockchip_drm_sys_resume(struct device *dev) 251 { 252 struct drm_device *drm = dev_get_drvdata(dev); 253 254 return drm_mode_config_helper_resume(drm); 255 } 256 #endif 257 258 static const struct dev_pm_ops rockchip_drm_pm_ops = { 259 SET_SYSTEM_SLEEP_PM_OPS(rockchip_drm_sys_suspend, 260 rockchip_drm_sys_resume) 261 }; 262 263 #define MAX_ROCKCHIP_SUB_DRIVERS 16 264 static struct platform_driver *rockchip_sub_drivers[MAX_ROCKCHIP_SUB_DRIVERS]; 265 static int num_rockchip_sub_drivers; 266 267 /* 268 * Get the endpoint id of the remote endpoint of the given encoder. This 269 * information is used by the VOP2 driver to identify the encoder. 270 * 271 * @rkencoder: The encoder to get the remote endpoint id from 272 * @np: The encoder device node 273 * @port: The number of the port leading to the VOP2 274 * @reg: The endpoint number leading to the VOP2 275 */ 276 int rockchip_drm_encoder_set_crtc_endpoint_id(struct rockchip_encoder *rkencoder, 277 struct device_node *np, int port, int reg) 278 { 279 struct of_endpoint ep; 280 struct device_node *en, *ren; 281 int ret; 282 283 en = of_graph_get_endpoint_by_regs(np, port, reg); 284 if (!en) 285 return -ENOENT; 286 287 ren = of_graph_get_remote_endpoint(en); 288 if (!ren) 289 return -ENOENT; 290 291 ret = of_graph_parse_endpoint(ren, &ep); 292 if (ret) 293 return ret; 294 295 rkencoder->crtc_endpoint_id = ep.id; 296 297 return 0; 298 } 299 300 /* 301 * Check if a vop endpoint is leading to a rockchip subdriver or bridge. 302 * Should be called from the component bind stage of the drivers 303 * to ensure that all subdrivers are probed. 304 * 305 * @ep: endpoint of a rockchip vop 306 * 307 * returns true if subdriver, false if external bridge and -ENODEV 308 * if remote port does not contain a device. 309 */ 310 int rockchip_drm_endpoint_is_subdriver(struct device_node *ep) 311 { 312 struct device_node *node = of_graph_get_remote_port_parent(ep); 313 struct platform_device *pdev; 314 struct device_driver *drv; 315 int i; 316 317 if (!node) 318 return -ENODEV; 319 320 /* status disabled will prevent creation of platform-devices */ 321 if (!of_device_is_available(node)) { 322 of_node_put(node); 323 return -ENODEV; 324 } 325 326 pdev = of_find_device_by_node(node); 327 of_node_put(node); 328 329 /* enabled non-platform-devices can immediately return here */ 330 if (!pdev) 331 return false; 332 333 /* 334 * All rockchip subdrivers have probed at this point, so 335 * any device not having a driver now is an external bridge. 336 */ 337 drv = pdev->dev.driver; 338 if (!drv) { 339 platform_device_put(pdev); 340 return false; 341 } 342 343 for (i = 0; i < num_rockchip_sub_drivers; i++) { 344 if (rockchip_sub_drivers[i] == to_platform_driver(drv)) { 345 platform_device_put(pdev); 346 return true; 347 } 348 } 349 350 platform_device_put(pdev); 351 return false; 352 } 353 354 static void rockchip_drm_match_remove(struct device *dev) 355 { 356 struct device_link *link; 357 358 list_for_each_entry(link, &dev->links.consumers, s_node) 359 device_link_del(link); 360 } 361 362 /* list of preferred vop devices */ 363 static const char *const rockchip_drm_match_preferred[] = { 364 "rockchip,rk3399-vop-big", 365 NULL, 366 }; 367 368 static struct component_match *rockchip_drm_match_add(struct device *dev) 369 { 370 struct component_match *match = NULL; 371 struct device_node *port; 372 int i; 373 374 /* add preferred vop device match before adding driver device matches */ 375 for (i = 0; ; i++) { 376 port = of_parse_phandle(dev->of_node, "ports", i); 377 if (!port) 378 break; 379 380 if (of_device_is_available(port->parent) && 381 of_device_compatible_match(port->parent, 382 rockchip_drm_match_preferred)) 383 drm_of_component_match_add(dev, &match, 384 component_compare_of, 385 port->parent); 386 387 of_node_put(port); 388 } 389 390 for (i = 0; i < num_rockchip_sub_drivers; i++) { 391 struct platform_driver *drv = rockchip_sub_drivers[i]; 392 struct device *p = NULL, *d; 393 394 do { 395 d = platform_find_device_by_driver(p, &drv->driver); 396 put_device(p); 397 p = d; 398 399 if (!d) 400 break; 401 402 device_link_add(dev, d, DL_FLAG_STATELESS); 403 component_match_add(dev, &match, component_compare_dev, d); 404 } while (true); 405 } 406 407 if (IS_ERR(match)) 408 rockchip_drm_match_remove(dev); 409 410 return match ?: ERR_PTR(-ENODEV); 411 } 412 413 static const struct component_master_ops rockchip_drm_ops = { 414 .bind = rockchip_drm_bind, 415 .unbind = rockchip_drm_unbind, 416 }; 417 418 static int rockchip_drm_platform_of_probe(struct device *dev) 419 { 420 struct device_node *np = dev->of_node; 421 struct device_node *port; 422 bool found = false; 423 int i; 424 425 if (!np) 426 return -ENODEV; 427 428 for (i = 0;; i++) { 429 port = of_parse_phandle(np, "ports", i); 430 if (!port) 431 break; 432 433 if (!of_device_is_available(port->parent)) { 434 of_node_put(port); 435 continue; 436 } 437 438 found = true; 439 of_node_put(port); 440 } 441 442 if (i == 0) { 443 DRM_DEV_ERROR(dev, "missing 'ports' property\n"); 444 return -ENODEV; 445 } 446 447 if (!found) { 448 DRM_DEV_ERROR(dev, 449 "No available vop found for display-subsystem.\n"); 450 return -ENODEV; 451 } 452 453 return 0; 454 } 455 456 static int rockchip_drm_platform_probe(struct platform_device *pdev) 457 { 458 struct device *dev = &pdev->dev; 459 struct component_match *match = NULL; 460 int ret; 461 462 ret = rockchip_drm_platform_of_probe(dev); 463 if (ret) 464 return ret; 465 466 match = rockchip_drm_match_add(dev); 467 if (IS_ERR(match)) 468 return PTR_ERR(match); 469 470 ret = component_master_add_with_match(dev, &rockchip_drm_ops, match); 471 if (ret < 0) { 472 rockchip_drm_match_remove(dev); 473 return ret; 474 } 475 476 return 0; 477 } 478 479 static void rockchip_drm_platform_remove(struct platform_device *pdev) 480 { 481 component_master_del(&pdev->dev, &rockchip_drm_ops); 482 483 rockchip_drm_match_remove(&pdev->dev); 484 } 485 486 static void rockchip_drm_platform_shutdown(struct platform_device *pdev) 487 { 488 if (component_master_is_bound(&pdev->dev, &rockchip_drm_ops)) { 489 struct drm_device *drm = platform_get_drvdata(pdev); 490 491 drm_atomic_helper_shutdown(drm); 492 } 493 } 494 495 static const struct of_device_id rockchip_drm_dt_ids[] = { 496 { .compatible = "rockchip,display-subsystem", }, 497 { /* sentinel */ }, 498 }; 499 MODULE_DEVICE_TABLE(of, rockchip_drm_dt_ids); 500 501 static struct platform_driver rockchip_drm_platform_driver = { 502 .probe = rockchip_drm_platform_probe, 503 .remove = rockchip_drm_platform_remove, 504 .shutdown = rockchip_drm_platform_shutdown, 505 .driver = { 506 .name = "rockchip-drm", 507 .of_match_table = rockchip_drm_dt_ids, 508 .pm = &rockchip_drm_pm_ops, 509 }, 510 }; 511 512 #define ADD_ROCKCHIP_SUB_DRIVER(drv, cond) { \ 513 if (IS_ENABLED(cond) && \ 514 !WARN_ON(num_rockchip_sub_drivers >= MAX_ROCKCHIP_SUB_DRIVERS)) \ 515 rockchip_sub_drivers[num_rockchip_sub_drivers++] = &drv; \ 516 } 517 518 static int __init rockchip_drm_init(void) 519 { 520 int ret; 521 522 if (drm_firmware_drivers_only()) 523 return -ENODEV; 524 525 num_rockchip_sub_drivers = 0; 526 ADD_ROCKCHIP_SUB_DRIVER(vop_platform_driver, CONFIG_ROCKCHIP_VOP); 527 ADD_ROCKCHIP_SUB_DRIVER(vop2_platform_driver, CONFIG_ROCKCHIP_VOP2); 528 ADD_ROCKCHIP_SUB_DRIVER(rockchip_lvds_driver, 529 CONFIG_ROCKCHIP_LVDS); 530 ADD_ROCKCHIP_SUB_DRIVER(rockchip_dp_driver, 531 CONFIG_ROCKCHIP_ANALOGIX_DP); 532 ADD_ROCKCHIP_SUB_DRIVER(cdn_dp_driver, CONFIG_ROCKCHIP_CDN_DP); 533 ADD_ROCKCHIP_SUB_DRIVER(dw_dp_driver, CONFIG_ROCKCHIP_DW_DP); 534 ADD_ROCKCHIP_SUB_DRIVER(dw_hdmi_rockchip_pltfm_driver, 535 CONFIG_ROCKCHIP_DW_HDMI); 536 ADD_ROCKCHIP_SUB_DRIVER(dw_hdmi_qp_rockchip_pltfm_driver, 537 CONFIG_ROCKCHIP_DW_HDMI_QP); 538 ADD_ROCKCHIP_SUB_DRIVER(dw_mipi_dsi_rockchip_driver, 539 CONFIG_ROCKCHIP_DW_MIPI_DSI); 540 ADD_ROCKCHIP_SUB_DRIVER(dw_mipi_dsi2_rockchip_driver, 541 CONFIG_ROCKCHIP_DW_MIPI_DSI2); 542 ADD_ROCKCHIP_SUB_DRIVER(inno_hdmi_driver, CONFIG_ROCKCHIP_INNO_HDMI); 543 ADD_ROCKCHIP_SUB_DRIVER(rk3066_hdmi_driver, 544 CONFIG_ROCKCHIP_RK3066_HDMI); 545 546 ret = platform_register_drivers(rockchip_sub_drivers, 547 num_rockchip_sub_drivers); 548 if (ret) 549 return ret; 550 551 ret = platform_driver_register(&rockchip_drm_platform_driver); 552 if (ret) 553 goto err_unreg_drivers; 554 555 return 0; 556 557 err_unreg_drivers: 558 platform_unregister_drivers(rockchip_sub_drivers, 559 num_rockchip_sub_drivers); 560 return ret; 561 } 562 563 static void __exit rockchip_drm_fini(void) 564 { 565 platform_driver_unregister(&rockchip_drm_platform_driver); 566 567 platform_unregister_drivers(rockchip_sub_drivers, 568 num_rockchip_sub_drivers); 569 } 570 571 module_init(rockchip_drm_init); 572 module_exit(rockchip_drm_fini); 573 574 MODULE_AUTHOR("Mark Yao <mark.yao@rock-chips.com>"); 575 MODULE_DESCRIPTION("ROCKCHIP DRM Driver"); 576 MODULE_LICENSE("GPL v2"); 577