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