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