1 /* 2 * Copyright (C) 2015 Etnaviv Project 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License version 2 as published by 6 * the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 * more details. 12 * 13 * You should have received a copy of the GNU General Public License along with 14 * this program. If not, see <http://www.gnu.org/licenses/>. 15 */ 16 17 #include <linux/component.h> 18 #include <linux/of_platform.h> 19 20 #include "etnaviv_drv.h" 21 #include "etnaviv_gpu.h" 22 #include "etnaviv_gem.h" 23 #include "etnaviv_mmu.h" 24 #include "etnaviv_gem.h" 25 26 #ifdef CONFIG_DRM_ETNAVIV_REGISTER_LOGGING 27 static bool reglog; 28 MODULE_PARM_DESC(reglog, "Enable register read/write logging"); 29 module_param(reglog, bool, 0600); 30 #else 31 #define reglog 0 32 #endif 33 34 void __iomem *etnaviv_ioremap(struct platform_device *pdev, const char *name, 35 const char *dbgname) 36 { 37 struct resource *res; 38 void __iomem *ptr; 39 40 if (name) 41 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name); 42 else 43 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 44 45 ptr = devm_ioremap_resource(&pdev->dev, res); 46 if (IS_ERR(ptr)) { 47 dev_err(&pdev->dev, "failed to ioremap %s: %ld\n", name, 48 PTR_ERR(ptr)); 49 return ptr; 50 } 51 52 if (reglog) 53 dev_printk(KERN_DEBUG, &pdev->dev, "IO:region %s 0x%p %08zx\n", 54 dbgname, ptr, (size_t)resource_size(res)); 55 56 return ptr; 57 } 58 59 void etnaviv_writel(u32 data, void __iomem *addr) 60 { 61 if (reglog) 62 printk(KERN_DEBUG "IO:W %p %08x\n", addr, data); 63 64 writel(data, addr); 65 } 66 67 u32 etnaviv_readl(const void __iomem *addr) 68 { 69 u32 val = readl(addr); 70 71 if (reglog) 72 printk(KERN_DEBUG "IO:R %p %08x\n", addr, val); 73 74 return val; 75 } 76 77 /* 78 * DRM operations: 79 */ 80 81 82 static void load_gpu(struct drm_device *dev) 83 { 84 struct etnaviv_drm_private *priv = dev->dev_private; 85 unsigned int i; 86 87 for (i = 0; i < ETNA_MAX_PIPES; i++) { 88 struct etnaviv_gpu *g = priv->gpu[i]; 89 90 if (g) { 91 int ret; 92 93 ret = etnaviv_gpu_init(g); 94 if (ret) { 95 dev_err(g->dev, "hw init failed: %d\n", ret); 96 priv->gpu[i] = NULL; 97 } 98 } 99 } 100 } 101 102 static int etnaviv_open(struct drm_device *dev, struct drm_file *file) 103 { 104 struct etnaviv_file_private *ctx; 105 106 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 107 if (!ctx) 108 return -ENOMEM; 109 110 file->driver_priv = ctx; 111 112 return 0; 113 } 114 115 static void etnaviv_preclose(struct drm_device *dev, struct drm_file *file) 116 { 117 struct etnaviv_drm_private *priv = dev->dev_private; 118 struct etnaviv_file_private *ctx = file->driver_priv; 119 unsigned int i; 120 121 for (i = 0; i < ETNA_MAX_PIPES; i++) { 122 struct etnaviv_gpu *gpu = priv->gpu[i]; 123 124 if (gpu) { 125 mutex_lock(&gpu->lock); 126 if (gpu->lastctx == ctx) 127 gpu->lastctx = NULL; 128 mutex_unlock(&gpu->lock); 129 } 130 } 131 132 kfree(ctx); 133 } 134 135 /* 136 * DRM debugfs: 137 */ 138 139 #ifdef CONFIG_DEBUG_FS 140 static int etnaviv_gem_show(struct drm_device *dev, struct seq_file *m) 141 { 142 struct etnaviv_drm_private *priv = dev->dev_private; 143 144 etnaviv_gem_describe_objects(priv, m); 145 146 return 0; 147 } 148 149 static int etnaviv_mm_show(struct drm_device *dev, struct seq_file *m) 150 { 151 int ret; 152 153 read_lock(&dev->vma_offset_manager->vm_lock); 154 ret = drm_mm_dump_table(m, &dev->vma_offset_manager->vm_addr_space_mm); 155 read_unlock(&dev->vma_offset_manager->vm_lock); 156 157 return ret; 158 } 159 160 static int etnaviv_mmu_show(struct etnaviv_gpu *gpu, struct seq_file *m) 161 { 162 seq_printf(m, "Active Objects (%s):\n", dev_name(gpu->dev)); 163 164 mutex_lock(&gpu->mmu->lock); 165 drm_mm_dump_table(m, &gpu->mmu->mm); 166 mutex_unlock(&gpu->mmu->lock); 167 168 return 0; 169 } 170 171 static void etnaviv_buffer_dump(struct etnaviv_gpu *gpu, struct seq_file *m) 172 { 173 struct etnaviv_cmdbuf *buf = gpu->buffer; 174 u32 size = buf->size; 175 u32 *ptr = buf->vaddr; 176 u32 i; 177 178 seq_printf(m, "virt %p - phys 0x%llx - free 0x%08x\n", 179 buf->vaddr, (u64)buf->paddr, size - buf->user_size); 180 181 for (i = 0; i < size / 4; i++) { 182 if (i && !(i % 4)) 183 seq_puts(m, "\n"); 184 if (i % 4 == 0) 185 seq_printf(m, "\t0x%p: ", ptr + i); 186 seq_printf(m, "%08x ", *(ptr + i)); 187 } 188 seq_puts(m, "\n"); 189 } 190 191 static int etnaviv_ring_show(struct etnaviv_gpu *gpu, struct seq_file *m) 192 { 193 seq_printf(m, "Ring Buffer (%s): ", dev_name(gpu->dev)); 194 195 mutex_lock(&gpu->lock); 196 etnaviv_buffer_dump(gpu, m); 197 mutex_unlock(&gpu->lock); 198 199 return 0; 200 } 201 202 static int show_unlocked(struct seq_file *m, void *arg) 203 { 204 struct drm_info_node *node = (struct drm_info_node *) m->private; 205 struct drm_device *dev = node->minor->dev; 206 int (*show)(struct drm_device *dev, struct seq_file *m) = 207 node->info_ent->data; 208 209 return show(dev, m); 210 } 211 212 static int show_each_gpu(struct seq_file *m, void *arg) 213 { 214 struct drm_info_node *node = (struct drm_info_node *) m->private; 215 struct drm_device *dev = node->minor->dev; 216 struct etnaviv_drm_private *priv = dev->dev_private; 217 struct etnaviv_gpu *gpu; 218 int (*show)(struct etnaviv_gpu *gpu, struct seq_file *m) = 219 node->info_ent->data; 220 unsigned int i; 221 int ret = 0; 222 223 for (i = 0; i < ETNA_MAX_PIPES; i++) { 224 gpu = priv->gpu[i]; 225 if (!gpu) 226 continue; 227 228 ret = show(gpu, m); 229 if (ret < 0) 230 break; 231 } 232 233 return ret; 234 } 235 236 static struct drm_info_list etnaviv_debugfs_list[] = { 237 {"gpu", show_each_gpu, 0, etnaviv_gpu_debugfs}, 238 {"gem", show_unlocked, 0, etnaviv_gem_show}, 239 { "mm", show_unlocked, 0, etnaviv_mm_show }, 240 {"mmu", show_each_gpu, 0, etnaviv_mmu_show}, 241 {"ring", show_each_gpu, 0, etnaviv_ring_show}, 242 }; 243 244 static int etnaviv_debugfs_init(struct drm_minor *minor) 245 { 246 struct drm_device *dev = minor->dev; 247 int ret; 248 249 ret = drm_debugfs_create_files(etnaviv_debugfs_list, 250 ARRAY_SIZE(etnaviv_debugfs_list), 251 minor->debugfs_root, minor); 252 253 if (ret) { 254 dev_err(dev->dev, "could not install etnaviv_debugfs_list\n"); 255 return ret; 256 } 257 258 return ret; 259 } 260 261 static void etnaviv_debugfs_cleanup(struct drm_minor *minor) 262 { 263 drm_debugfs_remove_files(etnaviv_debugfs_list, 264 ARRAY_SIZE(etnaviv_debugfs_list), minor); 265 } 266 #endif 267 268 /* 269 * DRM ioctls: 270 */ 271 272 static int etnaviv_ioctl_get_param(struct drm_device *dev, void *data, 273 struct drm_file *file) 274 { 275 struct etnaviv_drm_private *priv = dev->dev_private; 276 struct drm_etnaviv_param *args = data; 277 struct etnaviv_gpu *gpu; 278 279 if (args->pipe >= ETNA_MAX_PIPES) 280 return -EINVAL; 281 282 gpu = priv->gpu[args->pipe]; 283 if (!gpu) 284 return -ENXIO; 285 286 return etnaviv_gpu_get_param(gpu, args->param, &args->value); 287 } 288 289 static int etnaviv_ioctl_gem_new(struct drm_device *dev, void *data, 290 struct drm_file *file) 291 { 292 struct drm_etnaviv_gem_new *args = data; 293 294 if (args->flags & ~(ETNA_BO_CACHED | ETNA_BO_WC | ETNA_BO_UNCACHED | 295 ETNA_BO_FORCE_MMU)) 296 return -EINVAL; 297 298 return etnaviv_gem_new_handle(dev, file, args->size, 299 args->flags, &args->handle); 300 } 301 302 #define TS(t) ((struct timespec){ \ 303 .tv_sec = (t).tv_sec, \ 304 .tv_nsec = (t).tv_nsec \ 305 }) 306 307 static int etnaviv_ioctl_gem_cpu_prep(struct drm_device *dev, void *data, 308 struct drm_file *file) 309 { 310 struct drm_etnaviv_gem_cpu_prep *args = data; 311 struct drm_gem_object *obj; 312 int ret; 313 314 if (args->op & ~(ETNA_PREP_READ | ETNA_PREP_WRITE | ETNA_PREP_NOSYNC)) 315 return -EINVAL; 316 317 obj = drm_gem_object_lookup(dev, file, args->handle); 318 if (!obj) 319 return -ENOENT; 320 321 ret = etnaviv_gem_cpu_prep(obj, args->op, &TS(args->timeout)); 322 323 drm_gem_object_unreference_unlocked(obj); 324 325 return ret; 326 } 327 328 static int etnaviv_ioctl_gem_cpu_fini(struct drm_device *dev, void *data, 329 struct drm_file *file) 330 { 331 struct drm_etnaviv_gem_cpu_fini *args = data; 332 struct drm_gem_object *obj; 333 int ret; 334 335 if (args->flags) 336 return -EINVAL; 337 338 obj = drm_gem_object_lookup(dev, file, args->handle); 339 if (!obj) 340 return -ENOENT; 341 342 ret = etnaviv_gem_cpu_fini(obj); 343 344 drm_gem_object_unreference_unlocked(obj); 345 346 return ret; 347 } 348 349 static int etnaviv_ioctl_gem_info(struct drm_device *dev, void *data, 350 struct drm_file *file) 351 { 352 struct drm_etnaviv_gem_info *args = data; 353 struct drm_gem_object *obj; 354 int ret; 355 356 if (args->pad) 357 return -EINVAL; 358 359 obj = drm_gem_object_lookup(dev, file, args->handle); 360 if (!obj) 361 return -ENOENT; 362 363 ret = etnaviv_gem_mmap_offset(obj, &args->offset); 364 drm_gem_object_unreference_unlocked(obj); 365 366 return ret; 367 } 368 369 static int etnaviv_ioctl_wait_fence(struct drm_device *dev, void *data, 370 struct drm_file *file) 371 { 372 struct drm_etnaviv_wait_fence *args = data; 373 struct etnaviv_drm_private *priv = dev->dev_private; 374 struct timespec *timeout = &TS(args->timeout); 375 struct etnaviv_gpu *gpu; 376 377 if (args->flags & ~(ETNA_WAIT_NONBLOCK)) 378 return -EINVAL; 379 380 if (args->pipe >= ETNA_MAX_PIPES) 381 return -EINVAL; 382 383 gpu = priv->gpu[args->pipe]; 384 if (!gpu) 385 return -ENXIO; 386 387 if (args->flags & ETNA_WAIT_NONBLOCK) 388 timeout = NULL; 389 390 return etnaviv_gpu_wait_fence_interruptible(gpu, args->fence, 391 timeout); 392 } 393 394 static int etnaviv_ioctl_gem_userptr(struct drm_device *dev, void *data, 395 struct drm_file *file) 396 { 397 struct drm_etnaviv_gem_userptr *args = data; 398 int access; 399 400 if (args->flags & ~(ETNA_USERPTR_READ|ETNA_USERPTR_WRITE) || 401 args->flags == 0) 402 return -EINVAL; 403 404 if (offset_in_page(args->user_ptr | args->user_size) || 405 (uintptr_t)args->user_ptr != args->user_ptr || 406 (u32)args->user_size != args->user_size || 407 args->user_ptr & ~PAGE_MASK) 408 return -EINVAL; 409 410 if (args->flags & ETNA_USERPTR_WRITE) 411 access = VERIFY_WRITE; 412 else 413 access = VERIFY_READ; 414 415 if (!access_ok(access, (void __user *)(unsigned long)args->user_ptr, 416 args->user_size)) 417 return -EFAULT; 418 419 return etnaviv_gem_new_userptr(dev, file, args->user_ptr, 420 args->user_size, args->flags, 421 &args->handle); 422 } 423 424 static int etnaviv_ioctl_gem_wait(struct drm_device *dev, void *data, 425 struct drm_file *file) 426 { 427 struct etnaviv_drm_private *priv = dev->dev_private; 428 struct drm_etnaviv_gem_wait *args = data; 429 struct timespec *timeout = &TS(args->timeout); 430 struct drm_gem_object *obj; 431 struct etnaviv_gpu *gpu; 432 int ret; 433 434 if (args->flags & ~(ETNA_WAIT_NONBLOCK)) 435 return -EINVAL; 436 437 if (args->pipe >= ETNA_MAX_PIPES) 438 return -EINVAL; 439 440 gpu = priv->gpu[args->pipe]; 441 if (!gpu) 442 return -ENXIO; 443 444 obj = drm_gem_object_lookup(dev, file, args->handle); 445 if (!obj) 446 return -ENOENT; 447 448 if (args->flags & ETNA_WAIT_NONBLOCK) 449 timeout = NULL; 450 451 ret = etnaviv_gem_wait_bo(gpu, obj, timeout); 452 453 drm_gem_object_unreference_unlocked(obj); 454 455 return ret; 456 } 457 458 static const struct drm_ioctl_desc etnaviv_ioctls[] = { 459 #define ETNA_IOCTL(n, func, flags) \ 460 DRM_IOCTL_DEF_DRV(ETNAVIV_##n, etnaviv_ioctl_##func, flags) 461 ETNA_IOCTL(GET_PARAM, get_param, DRM_AUTH|DRM_RENDER_ALLOW), 462 ETNA_IOCTL(GEM_NEW, gem_new, DRM_AUTH|DRM_RENDER_ALLOW), 463 ETNA_IOCTL(GEM_INFO, gem_info, DRM_AUTH|DRM_RENDER_ALLOW), 464 ETNA_IOCTL(GEM_CPU_PREP, gem_cpu_prep, DRM_AUTH|DRM_RENDER_ALLOW), 465 ETNA_IOCTL(GEM_CPU_FINI, gem_cpu_fini, DRM_AUTH|DRM_RENDER_ALLOW), 466 ETNA_IOCTL(GEM_SUBMIT, gem_submit, DRM_AUTH|DRM_RENDER_ALLOW), 467 ETNA_IOCTL(WAIT_FENCE, wait_fence, DRM_AUTH|DRM_RENDER_ALLOW), 468 ETNA_IOCTL(GEM_USERPTR, gem_userptr, DRM_AUTH|DRM_RENDER_ALLOW), 469 ETNA_IOCTL(GEM_WAIT, gem_wait, DRM_AUTH|DRM_RENDER_ALLOW), 470 }; 471 472 static const struct vm_operations_struct vm_ops = { 473 .fault = etnaviv_gem_fault, 474 .open = drm_gem_vm_open, 475 .close = drm_gem_vm_close, 476 }; 477 478 static const struct file_operations fops = { 479 .owner = THIS_MODULE, 480 .open = drm_open, 481 .release = drm_release, 482 .unlocked_ioctl = drm_ioctl, 483 #ifdef CONFIG_COMPAT 484 .compat_ioctl = drm_compat_ioctl, 485 #endif 486 .poll = drm_poll, 487 .read = drm_read, 488 .llseek = no_llseek, 489 .mmap = etnaviv_gem_mmap, 490 }; 491 492 static struct drm_driver etnaviv_drm_driver = { 493 .driver_features = DRIVER_HAVE_IRQ | 494 DRIVER_GEM | 495 DRIVER_PRIME | 496 DRIVER_RENDER, 497 .open = etnaviv_open, 498 .preclose = etnaviv_preclose, 499 .set_busid = drm_platform_set_busid, 500 .gem_free_object_unlocked = etnaviv_gem_free_object, 501 .gem_vm_ops = &vm_ops, 502 .prime_handle_to_fd = drm_gem_prime_handle_to_fd, 503 .prime_fd_to_handle = drm_gem_prime_fd_to_handle, 504 .gem_prime_export = drm_gem_prime_export, 505 .gem_prime_import = drm_gem_prime_import, 506 .gem_prime_pin = etnaviv_gem_prime_pin, 507 .gem_prime_unpin = etnaviv_gem_prime_unpin, 508 .gem_prime_get_sg_table = etnaviv_gem_prime_get_sg_table, 509 .gem_prime_import_sg_table = etnaviv_gem_prime_import_sg_table, 510 .gem_prime_vmap = etnaviv_gem_prime_vmap, 511 .gem_prime_vunmap = etnaviv_gem_prime_vunmap, 512 #ifdef CONFIG_DEBUG_FS 513 .debugfs_init = etnaviv_debugfs_init, 514 .debugfs_cleanup = etnaviv_debugfs_cleanup, 515 #endif 516 .ioctls = etnaviv_ioctls, 517 .num_ioctls = DRM_ETNAVIV_NUM_IOCTLS, 518 .fops = &fops, 519 .name = "etnaviv", 520 .desc = "etnaviv DRM", 521 .date = "20151214", 522 .major = 1, 523 .minor = 0, 524 }; 525 526 /* 527 * Platform driver: 528 */ 529 static int etnaviv_bind(struct device *dev) 530 { 531 struct etnaviv_drm_private *priv; 532 struct drm_device *drm; 533 int ret; 534 535 drm = drm_dev_alloc(&etnaviv_drm_driver, dev); 536 if (!drm) 537 return -ENOMEM; 538 539 drm->platformdev = to_platform_device(dev); 540 541 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 542 if (!priv) { 543 dev_err(dev, "failed to allocate private data\n"); 544 ret = -ENOMEM; 545 goto out_unref; 546 } 547 drm->dev_private = priv; 548 549 priv->wq = alloc_ordered_workqueue("etnaviv", 0); 550 if (!priv->wq) { 551 ret = -ENOMEM; 552 goto out_wq; 553 } 554 555 mutex_init(&priv->gem_lock); 556 INIT_LIST_HEAD(&priv->gem_list); 557 priv->num_gpus = 0; 558 559 dev_set_drvdata(dev, drm); 560 561 ret = component_bind_all(dev, drm); 562 if (ret < 0) 563 goto out_bind; 564 565 load_gpu(drm); 566 567 ret = drm_dev_register(drm, 0); 568 if (ret) 569 goto out_register; 570 571 return 0; 572 573 out_register: 574 component_unbind_all(dev, drm); 575 out_bind: 576 flush_workqueue(priv->wq); 577 destroy_workqueue(priv->wq); 578 out_wq: 579 kfree(priv); 580 out_unref: 581 drm_dev_unref(drm); 582 583 return ret; 584 } 585 586 static void etnaviv_unbind(struct device *dev) 587 { 588 struct drm_device *drm = dev_get_drvdata(dev); 589 struct etnaviv_drm_private *priv = drm->dev_private; 590 591 drm_dev_unregister(drm); 592 593 flush_workqueue(priv->wq); 594 destroy_workqueue(priv->wq); 595 596 component_unbind_all(dev, drm); 597 598 drm->dev_private = NULL; 599 kfree(priv); 600 601 drm_put_dev(drm); 602 } 603 604 static const struct component_master_ops etnaviv_master_ops = { 605 .bind = etnaviv_bind, 606 .unbind = etnaviv_unbind, 607 }; 608 609 static int compare_of(struct device *dev, void *data) 610 { 611 struct device_node *np = data; 612 613 return dev->of_node == np; 614 } 615 616 static int compare_str(struct device *dev, void *data) 617 { 618 return !strcmp(dev_name(dev), data); 619 } 620 621 static int etnaviv_pdev_probe(struct platform_device *pdev) 622 { 623 struct device *dev = &pdev->dev; 624 struct device_node *node = dev->of_node; 625 struct component_match *match = NULL; 626 627 dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); 628 629 if (node) { 630 struct device_node *core_node; 631 int i; 632 633 for (i = 0; ; i++) { 634 core_node = of_parse_phandle(node, "cores", i); 635 if (!core_node) 636 break; 637 638 component_match_add(&pdev->dev, &match, compare_of, 639 core_node); 640 of_node_put(core_node); 641 } 642 } else if (dev->platform_data) { 643 char **names = dev->platform_data; 644 unsigned i; 645 646 for (i = 0; names[i]; i++) 647 component_match_add(dev, &match, compare_str, names[i]); 648 } 649 650 return component_master_add_with_match(dev, &etnaviv_master_ops, match); 651 } 652 653 static int etnaviv_pdev_remove(struct platform_device *pdev) 654 { 655 component_master_del(&pdev->dev, &etnaviv_master_ops); 656 657 return 0; 658 } 659 660 static const struct of_device_id dt_match[] = { 661 { .compatible = "fsl,imx-gpu-subsystem" }, 662 { .compatible = "marvell,dove-gpu-subsystem" }, 663 {} 664 }; 665 MODULE_DEVICE_TABLE(of, dt_match); 666 667 static struct platform_driver etnaviv_platform_driver = { 668 .probe = etnaviv_pdev_probe, 669 .remove = etnaviv_pdev_remove, 670 .driver = { 671 .name = "etnaviv", 672 .of_match_table = dt_match, 673 }, 674 }; 675 676 static int __init etnaviv_init(void) 677 { 678 int ret; 679 680 etnaviv_validate_init(); 681 682 ret = platform_driver_register(&etnaviv_gpu_driver); 683 if (ret != 0) 684 return ret; 685 686 ret = platform_driver_register(&etnaviv_platform_driver); 687 if (ret != 0) 688 platform_driver_unregister(&etnaviv_gpu_driver); 689 690 return ret; 691 } 692 module_init(etnaviv_init); 693 694 static void __exit etnaviv_exit(void) 695 { 696 platform_driver_unregister(&etnaviv_gpu_driver); 697 platform_driver_unregister(&etnaviv_platform_driver); 698 } 699 module_exit(etnaviv_exit); 700 701 MODULE_AUTHOR("Christian Gmeiner <christian.gmeiner@gmail.com>"); 702 MODULE_AUTHOR("Russell King <rmk+kernel@arm.linux.org.uk>"); 703 MODULE_AUTHOR("Lucas Stach <l.stach@pengutronix.de>"); 704 MODULE_DESCRIPTION("etnaviv DRM Driver"); 705 MODULE_LICENSE("GPL v2"); 706 MODULE_ALIAS("platform:etnaviv"); 707