1 // SPDX-License-Identifier: GPL-2.0-or-later 2 #include <linux/compat.h> 3 #include <linux/dma-mapping.h> 4 #include <linux/iommu.h> 5 #include <linux/module.h> 6 #include <linux/poll.h> 7 #include <linux/slab.h> 8 #include <linux/uacce.h> 9 10 static struct class *uacce_class; 11 static dev_t uacce_devt; 12 static DEFINE_XARRAY_ALLOC(uacce_xa); 13 14 /* 15 * If the parent driver or the device disappears, the queue state is invalid and 16 * ops are not usable anymore. 17 */ 18 static bool uacce_queue_is_valid(struct uacce_queue *q) 19 { 20 return q->state == UACCE_Q_INIT || q->state == UACCE_Q_STARTED; 21 } 22 23 static int uacce_start_queue(struct uacce_queue *q) 24 { 25 int ret; 26 27 if (q->state != UACCE_Q_INIT) 28 return -EINVAL; 29 30 if (q->uacce->ops->start_queue) { 31 ret = q->uacce->ops->start_queue(q); 32 if (ret < 0) 33 return ret; 34 } 35 36 q->state = UACCE_Q_STARTED; 37 return 0; 38 } 39 40 static int uacce_put_queue(struct uacce_queue *q) 41 { 42 struct uacce_device *uacce = q->uacce; 43 44 if ((q->state == UACCE_Q_STARTED) && uacce->ops->stop_queue) 45 uacce->ops->stop_queue(q); 46 47 if ((q->state == UACCE_Q_INIT || q->state == UACCE_Q_STARTED) && 48 uacce->ops->put_queue) 49 uacce->ops->put_queue(q); 50 51 q->state = UACCE_Q_ZOMBIE; 52 53 return 0; 54 } 55 56 static long uacce_fops_unl_ioctl(struct file *filep, 57 unsigned int cmd, unsigned long arg) 58 { 59 struct uacce_queue *q = filep->private_data; 60 struct uacce_device *uacce = q->uacce; 61 long ret = -ENXIO; 62 63 /* 64 * uacce->ops->ioctl() may take the mmap_lock when copying arg to/from 65 * user. Avoid a circular lock dependency with uacce_fops_mmap(), which 66 * gets called with mmap_lock held, by taking uacce->mutex instead of 67 * q->mutex. Doing this in uacce_fops_mmap() is not possible because 68 * uacce_fops_open() calls iommu_sva_bind_device(), which takes 69 * mmap_lock, while holding uacce->mutex. 70 */ 71 mutex_lock(&uacce->mutex); 72 if (!uacce_queue_is_valid(q)) 73 goto out_unlock; 74 75 switch (cmd) { 76 case UACCE_CMD_START_Q: 77 ret = uacce_start_queue(q); 78 break; 79 case UACCE_CMD_PUT_Q: 80 ret = uacce_put_queue(q); 81 break; 82 default: 83 if (uacce->ops->ioctl) 84 ret = uacce->ops->ioctl(q, cmd, arg); 85 else 86 ret = -EINVAL; 87 } 88 out_unlock: 89 mutex_unlock(&uacce->mutex); 90 return ret; 91 } 92 93 #ifdef CONFIG_COMPAT 94 static long uacce_fops_compat_ioctl(struct file *filep, 95 unsigned int cmd, unsigned long arg) 96 { 97 arg = (unsigned long)compat_ptr(arg); 98 99 return uacce_fops_unl_ioctl(filep, cmd, arg); 100 } 101 #endif 102 103 static int uacce_bind_queue(struct uacce_device *uacce, struct uacce_queue *q) 104 { 105 u32 pasid; 106 struct iommu_sva *handle; 107 108 if (!(uacce->flags & UACCE_DEV_SVA)) 109 return 0; 110 111 handle = iommu_sva_bind_device(uacce->parent, current->mm); 112 if (IS_ERR(handle)) 113 return PTR_ERR(handle); 114 115 pasid = iommu_sva_get_pasid(handle); 116 if (pasid == IOMMU_PASID_INVALID) { 117 iommu_sva_unbind_device(handle); 118 return -ENODEV; 119 } 120 121 q->handle = handle; 122 q->pasid = pasid; 123 return 0; 124 } 125 126 static void uacce_unbind_queue(struct uacce_queue *q) 127 { 128 if (!q->handle) 129 return; 130 iommu_sva_unbind_device(q->handle); 131 q->handle = NULL; 132 } 133 134 static int uacce_fops_open(struct inode *inode, struct file *filep) 135 { 136 struct uacce_device *uacce; 137 struct uacce_queue *q; 138 int ret; 139 140 uacce = xa_load(&uacce_xa, iminor(inode)); 141 if (!uacce) 142 return -ENODEV; 143 144 q = kzalloc(sizeof(struct uacce_queue), GFP_KERNEL); 145 if (!q) 146 return -ENOMEM; 147 148 mutex_lock(&uacce->mutex); 149 150 if (!uacce->parent) { 151 ret = -EINVAL; 152 goto out_with_mem; 153 } 154 155 ret = uacce_bind_queue(uacce, q); 156 if (ret) 157 goto out_with_mem; 158 159 q->uacce = uacce; 160 161 if (uacce->ops->get_queue) { 162 ret = uacce->ops->get_queue(uacce, q->pasid, q); 163 if (ret < 0) 164 goto out_with_bond; 165 } 166 167 init_waitqueue_head(&q->wait); 168 filep->private_data = q; 169 uacce->inode = inode; 170 q->state = UACCE_Q_INIT; 171 mutex_init(&q->mutex); 172 list_add(&q->list, &uacce->queues); 173 mutex_unlock(&uacce->mutex); 174 175 return 0; 176 177 out_with_bond: 178 uacce_unbind_queue(q); 179 out_with_mem: 180 kfree(q); 181 mutex_unlock(&uacce->mutex); 182 return ret; 183 } 184 185 static int uacce_fops_release(struct inode *inode, struct file *filep) 186 { 187 struct uacce_queue *q = filep->private_data; 188 struct uacce_device *uacce = q->uacce; 189 190 mutex_lock(&uacce->mutex); 191 uacce_put_queue(q); 192 uacce_unbind_queue(q); 193 list_del(&q->list); 194 mutex_unlock(&uacce->mutex); 195 kfree(q); 196 197 return 0; 198 } 199 200 static void uacce_vma_close(struct vm_area_struct *vma) 201 { 202 struct uacce_queue *q = vma->vm_private_data; 203 struct uacce_qfile_region *qfr = NULL; 204 205 if (vma->vm_pgoff < UACCE_MAX_REGION) 206 qfr = q->qfrs[vma->vm_pgoff]; 207 208 kfree(qfr); 209 } 210 211 static const struct vm_operations_struct uacce_vm_ops = { 212 .close = uacce_vma_close, 213 }; 214 215 static int uacce_fops_mmap(struct file *filep, struct vm_area_struct *vma) 216 { 217 struct uacce_queue *q = filep->private_data; 218 struct uacce_device *uacce = q->uacce; 219 struct uacce_qfile_region *qfr; 220 enum uacce_qfrt type = UACCE_MAX_REGION; 221 int ret = 0; 222 223 if (vma->vm_pgoff < UACCE_MAX_REGION) 224 type = vma->vm_pgoff; 225 else 226 return -EINVAL; 227 228 qfr = kzalloc(sizeof(*qfr), GFP_KERNEL); 229 if (!qfr) 230 return -ENOMEM; 231 232 vm_flags_set(vma, VM_DONTCOPY | VM_DONTEXPAND | VM_WIPEONFORK); 233 vma->vm_ops = &uacce_vm_ops; 234 vma->vm_private_data = q; 235 qfr->type = type; 236 237 mutex_lock(&q->mutex); 238 if (!uacce_queue_is_valid(q)) { 239 ret = -ENXIO; 240 goto out_with_lock; 241 } 242 243 if (q->qfrs[type]) { 244 ret = -EEXIST; 245 goto out_with_lock; 246 } 247 248 switch (type) { 249 case UACCE_QFRT_MMIO: 250 case UACCE_QFRT_DUS: 251 if (!uacce->ops->mmap) { 252 ret = -EINVAL; 253 goto out_with_lock; 254 } 255 256 ret = uacce->ops->mmap(q, vma, qfr); 257 if (ret) 258 goto out_with_lock; 259 break; 260 261 default: 262 ret = -EINVAL; 263 goto out_with_lock; 264 } 265 266 q->qfrs[type] = qfr; 267 mutex_unlock(&q->mutex); 268 269 return ret; 270 271 out_with_lock: 272 mutex_unlock(&q->mutex); 273 kfree(qfr); 274 return ret; 275 } 276 277 static __poll_t uacce_fops_poll(struct file *file, poll_table *wait) 278 { 279 struct uacce_queue *q = file->private_data; 280 struct uacce_device *uacce = q->uacce; 281 __poll_t ret = 0; 282 283 mutex_lock(&q->mutex); 284 if (!uacce_queue_is_valid(q)) 285 goto out_unlock; 286 287 poll_wait(file, &q->wait, wait); 288 289 if (uacce->ops->is_q_updated && uacce->ops->is_q_updated(q)) 290 ret = EPOLLIN | EPOLLRDNORM; 291 292 out_unlock: 293 mutex_unlock(&q->mutex); 294 return ret; 295 } 296 297 static const struct file_operations uacce_fops = { 298 .owner = THIS_MODULE, 299 .open = uacce_fops_open, 300 .release = uacce_fops_release, 301 .unlocked_ioctl = uacce_fops_unl_ioctl, 302 #ifdef CONFIG_COMPAT 303 .compat_ioctl = uacce_fops_compat_ioctl, 304 #endif 305 .mmap = uacce_fops_mmap, 306 .poll = uacce_fops_poll, 307 }; 308 309 #define to_uacce_device(dev) container_of(dev, struct uacce_device, dev) 310 311 static ssize_t api_show(struct device *dev, 312 struct device_attribute *attr, char *buf) 313 { 314 struct uacce_device *uacce = to_uacce_device(dev); 315 316 return sysfs_emit(buf, "%s\n", uacce->api_ver); 317 } 318 319 static ssize_t flags_show(struct device *dev, 320 struct device_attribute *attr, char *buf) 321 { 322 struct uacce_device *uacce = to_uacce_device(dev); 323 324 return sysfs_emit(buf, "%u\n", uacce->flags); 325 } 326 327 static ssize_t available_instances_show(struct device *dev, 328 struct device_attribute *attr, 329 char *buf) 330 { 331 struct uacce_device *uacce = to_uacce_device(dev); 332 333 if (!uacce->ops->get_available_instances) 334 return -ENODEV; 335 336 return sysfs_emit(buf, "%d\n", 337 uacce->ops->get_available_instances(uacce)); 338 } 339 340 static ssize_t algorithms_show(struct device *dev, 341 struct device_attribute *attr, char *buf) 342 { 343 struct uacce_device *uacce = to_uacce_device(dev); 344 345 return sysfs_emit(buf, "%s\n", uacce->algs); 346 } 347 348 static ssize_t region_mmio_size_show(struct device *dev, 349 struct device_attribute *attr, char *buf) 350 { 351 struct uacce_device *uacce = to_uacce_device(dev); 352 353 return sysfs_emit(buf, "%lu\n", 354 uacce->qf_pg_num[UACCE_QFRT_MMIO] << PAGE_SHIFT); 355 } 356 357 static ssize_t region_dus_size_show(struct device *dev, 358 struct device_attribute *attr, char *buf) 359 { 360 struct uacce_device *uacce = to_uacce_device(dev); 361 362 return sysfs_emit(buf, "%lu\n", 363 uacce->qf_pg_num[UACCE_QFRT_DUS] << PAGE_SHIFT); 364 } 365 366 static ssize_t isolate_show(struct device *dev, 367 struct device_attribute *attr, char *buf) 368 { 369 struct uacce_device *uacce = to_uacce_device(dev); 370 371 return sysfs_emit(buf, "%d\n", uacce->ops->get_isolate_state(uacce)); 372 } 373 374 static ssize_t isolate_strategy_show(struct device *dev, struct device_attribute *attr, char *buf) 375 { 376 struct uacce_device *uacce = to_uacce_device(dev); 377 u32 val; 378 379 val = uacce->ops->isolate_err_threshold_read(uacce); 380 381 return sysfs_emit(buf, "%u\n", val); 382 } 383 384 static ssize_t isolate_strategy_store(struct device *dev, struct device_attribute *attr, 385 const char *buf, size_t count) 386 { 387 struct uacce_device *uacce = to_uacce_device(dev); 388 unsigned long val; 389 int ret; 390 391 if (kstrtoul(buf, 0, &val) < 0) 392 return -EINVAL; 393 394 if (val > UACCE_MAX_ERR_THRESHOLD) 395 return -EINVAL; 396 397 ret = uacce->ops->isolate_err_threshold_write(uacce, val); 398 if (ret) 399 return ret; 400 401 return count; 402 } 403 404 static DEVICE_ATTR_RO(api); 405 static DEVICE_ATTR_RO(flags); 406 static DEVICE_ATTR_RO(available_instances); 407 static DEVICE_ATTR_RO(algorithms); 408 static DEVICE_ATTR_RO(region_mmio_size); 409 static DEVICE_ATTR_RO(region_dus_size); 410 static DEVICE_ATTR_RO(isolate); 411 static DEVICE_ATTR_RW(isolate_strategy); 412 413 static struct attribute *uacce_dev_attrs[] = { 414 &dev_attr_api.attr, 415 &dev_attr_flags.attr, 416 &dev_attr_available_instances.attr, 417 &dev_attr_algorithms.attr, 418 &dev_attr_region_mmio_size.attr, 419 &dev_attr_region_dus_size.attr, 420 &dev_attr_isolate.attr, 421 &dev_attr_isolate_strategy.attr, 422 NULL, 423 }; 424 425 static umode_t uacce_dev_is_visible(struct kobject *kobj, 426 struct attribute *attr, int n) 427 { 428 struct device *dev = kobj_to_dev(kobj); 429 struct uacce_device *uacce = to_uacce_device(dev); 430 431 if (((attr == &dev_attr_region_mmio_size.attr) && 432 (!uacce->qf_pg_num[UACCE_QFRT_MMIO])) || 433 ((attr == &dev_attr_region_dus_size.attr) && 434 (!uacce->qf_pg_num[UACCE_QFRT_DUS]))) 435 return 0; 436 437 if (attr == &dev_attr_isolate_strategy.attr && 438 (!uacce->ops->isolate_err_threshold_read && 439 !uacce->ops->isolate_err_threshold_write)) 440 return 0; 441 442 if (attr == &dev_attr_isolate.attr && !uacce->ops->get_isolate_state) 443 return 0; 444 445 return attr->mode; 446 } 447 448 static struct attribute_group uacce_dev_group = { 449 .is_visible = uacce_dev_is_visible, 450 .attrs = uacce_dev_attrs, 451 }; 452 453 __ATTRIBUTE_GROUPS(uacce_dev); 454 455 static void uacce_release(struct device *dev) 456 { 457 struct uacce_device *uacce = to_uacce_device(dev); 458 459 kfree(uacce); 460 } 461 462 static unsigned int uacce_enable_sva(struct device *parent, unsigned int flags) 463 { 464 int ret; 465 466 if (!(flags & UACCE_DEV_SVA)) 467 return flags; 468 469 flags &= ~UACCE_DEV_SVA; 470 471 ret = iommu_dev_enable_feature(parent, IOMMU_DEV_FEAT_IOPF); 472 if (ret) { 473 dev_err(parent, "failed to enable IOPF feature! ret = %pe\n", ERR_PTR(ret)); 474 return flags; 475 } 476 477 ret = iommu_dev_enable_feature(parent, IOMMU_DEV_FEAT_SVA); 478 if (ret) { 479 dev_err(parent, "failed to enable SVA feature! ret = %pe\n", ERR_PTR(ret)); 480 iommu_dev_disable_feature(parent, IOMMU_DEV_FEAT_IOPF); 481 return flags; 482 } 483 484 return flags | UACCE_DEV_SVA; 485 } 486 487 static void uacce_disable_sva(struct uacce_device *uacce) 488 { 489 if (!(uacce->flags & UACCE_DEV_SVA)) 490 return; 491 492 iommu_dev_disable_feature(uacce->parent, IOMMU_DEV_FEAT_SVA); 493 iommu_dev_disable_feature(uacce->parent, IOMMU_DEV_FEAT_IOPF); 494 } 495 496 /** 497 * uacce_alloc() - alloc an accelerator 498 * @parent: pointer of uacce parent device 499 * @interface: pointer of uacce_interface for register 500 * 501 * Returns uacce pointer if success and ERR_PTR if not 502 * Need check returned negotiated uacce->flags 503 */ 504 struct uacce_device *uacce_alloc(struct device *parent, 505 struct uacce_interface *interface) 506 { 507 unsigned int flags = interface->flags; 508 struct uacce_device *uacce; 509 int ret; 510 511 uacce = kzalloc(sizeof(struct uacce_device), GFP_KERNEL); 512 if (!uacce) 513 return ERR_PTR(-ENOMEM); 514 515 flags = uacce_enable_sva(parent, flags); 516 517 uacce->parent = parent; 518 uacce->flags = flags; 519 uacce->ops = interface->ops; 520 521 ret = xa_alloc(&uacce_xa, &uacce->dev_id, uacce, xa_limit_32b, 522 GFP_KERNEL); 523 if (ret < 0) 524 goto err_with_uacce; 525 526 INIT_LIST_HEAD(&uacce->queues); 527 mutex_init(&uacce->mutex); 528 device_initialize(&uacce->dev); 529 uacce->dev.devt = MKDEV(MAJOR(uacce_devt), uacce->dev_id); 530 uacce->dev.class = uacce_class; 531 uacce->dev.groups = uacce_dev_groups; 532 uacce->dev.parent = uacce->parent; 533 uacce->dev.release = uacce_release; 534 dev_set_name(&uacce->dev, "%s-%d", interface->name, uacce->dev_id); 535 536 return uacce; 537 538 err_with_uacce: 539 uacce_disable_sva(uacce); 540 kfree(uacce); 541 return ERR_PTR(ret); 542 } 543 EXPORT_SYMBOL_GPL(uacce_alloc); 544 545 /** 546 * uacce_register() - add the accelerator to cdev and export to user space 547 * @uacce: The initialized uacce device 548 * 549 * Return 0 if register succeeded, or an error. 550 */ 551 int uacce_register(struct uacce_device *uacce) 552 { 553 if (!uacce) 554 return -ENODEV; 555 556 uacce->cdev = cdev_alloc(); 557 if (!uacce->cdev) 558 return -ENOMEM; 559 560 uacce->cdev->ops = &uacce_fops; 561 uacce->cdev->owner = THIS_MODULE; 562 563 return cdev_device_add(uacce->cdev, &uacce->dev); 564 } 565 EXPORT_SYMBOL_GPL(uacce_register); 566 567 /** 568 * uacce_remove() - remove the accelerator 569 * @uacce: the accelerator to remove 570 */ 571 void uacce_remove(struct uacce_device *uacce) 572 { 573 struct uacce_queue *q, *next_q; 574 575 if (!uacce) 576 return; 577 /* 578 * unmap remaining mapping from user space, preventing user still 579 * access the mmaped area while parent device is already removed 580 */ 581 if (uacce->inode) 582 unmap_mapping_range(uacce->inode->i_mapping, 0, 0, 1); 583 584 /* 585 * uacce_fops_open() may be running concurrently, even after we remove 586 * the cdev. Holding uacce->mutex ensures that open() does not obtain a 587 * removed uacce device. 588 */ 589 mutex_lock(&uacce->mutex); 590 /* ensure no open queue remains */ 591 list_for_each_entry_safe(q, next_q, &uacce->queues, list) { 592 /* 593 * Taking q->mutex ensures that fops do not use the defunct 594 * uacce->ops after the queue is disabled. 595 */ 596 mutex_lock(&q->mutex); 597 uacce_put_queue(q); 598 mutex_unlock(&q->mutex); 599 uacce_unbind_queue(q); 600 } 601 602 /* disable sva now since no opened queues */ 603 uacce_disable_sva(uacce); 604 605 if (uacce->cdev) 606 cdev_device_del(uacce->cdev, &uacce->dev); 607 xa_erase(&uacce_xa, uacce->dev_id); 608 /* 609 * uacce exists as long as there are open fds, but ops will be freed 610 * now. Ensure that bugs cause NULL deref rather than use-after-free. 611 */ 612 uacce->ops = NULL; 613 uacce->parent = NULL; 614 mutex_unlock(&uacce->mutex); 615 put_device(&uacce->dev); 616 } 617 EXPORT_SYMBOL_GPL(uacce_remove); 618 619 static int __init uacce_init(void) 620 { 621 int ret; 622 623 uacce_class = class_create(THIS_MODULE, UACCE_NAME); 624 if (IS_ERR(uacce_class)) 625 return PTR_ERR(uacce_class); 626 627 ret = alloc_chrdev_region(&uacce_devt, 0, MINORMASK, UACCE_NAME); 628 if (ret) 629 class_destroy(uacce_class); 630 631 return ret; 632 } 633 634 static __exit void uacce_exit(void) 635 { 636 unregister_chrdev_region(uacce_devt, MINORMASK); 637 class_destroy(uacce_class); 638 } 639 640 subsys_initcall(uacce_init); 641 module_exit(uacce_exit); 642 643 MODULE_LICENSE("GPL"); 644 MODULE_AUTHOR("HiSilicon Tech. Co., Ltd."); 645 MODULE_DESCRIPTION("Accelerator interface for Userland applications"); 646