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