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