1 /* 2 * Copyright (C) 2013 - Virtual Open Systems 3 * Author: Antonios Motakis <a.motakis@virtualopensystems.com> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License, version 2, as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 */ 14 15 #include <linux/device.h> 16 #include <linux/iommu.h> 17 #include <linux/module.h> 18 #include <linux/mutex.h> 19 #include <linux/slab.h> 20 #include <linux/types.h> 21 #include <linux/uaccess.h> 22 #include <linux/vfio.h> 23 24 #include "vfio_platform_private.h" 25 26 #define DRIVER_VERSION "0.10" 27 #define DRIVER_AUTHOR "Antonios Motakis <a.motakis@virtualopensystems.com>" 28 #define DRIVER_DESC "VFIO platform base module" 29 30 static LIST_HEAD(reset_list); 31 static DEFINE_MUTEX(driver_lock); 32 33 static vfio_platform_reset_fn_t vfio_platform_lookup_reset(const char *compat, 34 struct module **module) 35 { 36 struct vfio_platform_reset_node *iter; 37 vfio_platform_reset_fn_t reset_fn = NULL; 38 39 mutex_lock(&driver_lock); 40 list_for_each_entry(iter, &reset_list, link) { 41 if (!strcmp(iter->compat, compat) && 42 try_module_get(iter->owner)) { 43 *module = iter->owner; 44 reset_fn = iter->reset; 45 break; 46 } 47 } 48 mutex_unlock(&driver_lock); 49 return reset_fn; 50 } 51 52 static void vfio_platform_get_reset(struct vfio_platform_device *vdev) 53 { 54 char modname[256]; 55 56 vdev->reset = vfio_platform_lookup_reset(vdev->compat, 57 &vdev->reset_module); 58 if (!vdev->reset) { 59 snprintf(modname, 256, "vfio-reset:%s", vdev->compat); 60 request_module(modname); 61 vdev->reset = vfio_platform_lookup_reset(vdev->compat, 62 &vdev->reset_module); 63 } 64 } 65 66 static void vfio_platform_put_reset(struct vfio_platform_device *vdev) 67 { 68 if (vdev->reset) 69 module_put(vdev->reset_module); 70 } 71 72 static int vfio_platform_regions_init(struct vfio_platform_device *vdev) 73 { 74 int cnt = 0, i; 75 76 while (vdev->get_resource(vdev, cnt)) 77 cnt++; 78 79 vdev->regions = kcalloc(cnt, sizeof(struct vfio_platform_region), 80 GFP_KERNEL); 81 if (!vdev->regions) 82 return -ENOMEM; 83 84 for (i = 0; i < cnt; i++) { 85 struct resource *res = 86 vdev->get_resource(vdev, i); 87 88 if (!res) 89 goto err; 90 91 vdev->regions[i].addr = res->start; 92 vdev->regions[i].size = resource_size(res); 93 vdev->regions[i].flags = 0; 94 95 switch (resource_type(res)) { 96 case IORESOURCE_MEM: 97 vdev->regions[i].type = VFIO_PLATFORM_REGION_TYPE_MMIO; 98 vdev->regions[i].flags |= VFIO_REGION_INFO_FLAG_READ; 99 if (!(res->flags & IORESOURCE_READONLY)) 100 vdev->regions[i].flags |= 101 VFIO_REGION_INFO_FLAG_WRITE; 102 103 /* 104 * Only regions addressed with PAGE granularity may be 105 * MMAPed securely. 106 */ 107 if (!(vdev->regions[i].addr & ~PAGE_MASK) && 108 !(vdev->regions[i].size & ~PAGE_MASK)) 109 vdev->regions[i].flags |= 110 VFIO_REGION_INFO_FLAG_MMAP; 111 112 break; 113 case IORESOURCE_IO: 114 vdev->regions[i].type = VFIO_PLATFORM_REGION_TYPE_PIO; 115 break; 116 default: 117 goto err; 118 } 119 } 120 121 vdev->num_regions = cnt; 122 123 return 0; 124 err: 125 kfree(vdev->regions); 126 return -EINVAL; 127 } 128 129 static void vfio_platform_regions_cleanup(struct vfio_platform_device *vdev) 130 { 131 int i; 132 133 for (i = 0; i < vdev->num_regions; i++) 134 iounmap(vdev->regions[i].ioaddr); 135 136 vdev->num_regions = 0; 137 kfree(vdev->regions); 138 } 139 140 static void vfio_platform_release(void *device_data) 141 { 142 struct vfio_platform_device *vdev = device_data; 143 144 mutex_lock(&driver_lock); 145 146 if (!(--vdev->refcnt)) { 147 if (vdev->reset) { 148 dev_info(vdev->device, "reset\n"); 149 vdev->reset(vdev); 150 } else { 151 dev_warn(vdev->device, "no reset function found!\n"); 152 } 153 vfio_platform_regions_cleanup(vdev); 154 vfio_platform_irq_cleanup(vdev); 155 } 156 157 mutex_unlock(&driver_lock); 158 159 module_put(vdev->parent_module); 160 } 161 162 static int vfio_platform_open(void *device_data) 163 { 164 struct vfio_platform_device *vdev = device_data; 165 int ret; 166 167 if (!try_module_get(vdev->parent_module)) 168 return -ENODEV; 169 170 mutex_lock(&driver_lock); 171 172 if (!vdev->refcnt) { 173 ret = vfio_platform_regions_init(vdev); 174 if (ret) 175 goto err_reg; 176 177 ret = vfio_platform_irq_init(vdev); 178 if (ret) 179 goto err_irq; 180 181 if (vdev->reset) { 182 dev_info(vdev->device, "reset\n"); 183 vdev->reset(vdev); 184 } else { 185 dev_warn(vdev->device, "no reset function found!\n"); 186 } 187 } 188 189 vdev->refcnt++; 190 191 mutex_unlock(&driver_lock); 192 return 0; 193 194 err_irq: 195 vfio_platform_regions_cleanup(vdev); 196 err_reg: 197 mutex_unlock(&driver_lock); 198 module_put(THIS_MODULE); 199 return ret; 200 } 201 202 static long vfio_platform_ioctl(void *device_data, 203 unsigned int cmd, unsigned long arg) 204 { 205 struct vfio_platform_device *vdev = device_data; 206 unsigned long minsz; 207 208 if (cmd == VFIO_DEVICE_GET_INFO) { 209 struct vfio_device_info info; 210 211 minsz = offsetofend(struct vfio_device_info, num_irqs); 212 213 if (copy_from_user(&info, (void __user *)arg, minsz)) 214 return -EFAULT; 215 216 if (info.argsz < minsz) 217 return -EINVAL; 218 219 if (vdev->reset) 220 vdev->flags |= VFIO_DEVICE_FLAGS_RESET; 221 info.flags = vdev->flags; 222 info.num_regions = vdev->num_regions; 223 info.num_irqs = vdev->num_irqs; 224 225 return copy_to_user((void __user *)arg, &info, minsz); 226 227 } else if (cmd == VFIO_DEVICE_GET_REGION_INFO) { 228 struct vfio_region_info info; 229 230 minsz = offsetofend(struct vfio_region_info, offset); 231 232 if (copy_from_user(&info, (void __user *)arg, minsz)) 233 return -EFAULT; 234 235 if (info.argsz < minsz) 236 return -EINVAL; 237 238 if (info.index >= vdev->num_regions) 239 return -EINVAL; 240 241 /* map offset to the physical address */ 242 info.offset = VFIO_PLATFORM_INDEX_TO_OFFSET(info.index); 243 info.size = vdev->regions[info.index].size; 244 info.flags = vdev->regions[info.index].flags; 245 246 return copy_to_user((void __user *)arg, &info, minsz); 247 248 } else if (cmd == VFIO_DEVICE_GET_IRQ_INFO) { 249 struct vfio_irq_info info; 250 251 minsz = offsetofend(struct vfio_irq_info, count); 252 253 if (copy_from_user(&info, (void __user *)arg, minsz)) 254 return -EFAULT; 255 256 if (info.argsz < minsz) 257 return -EINVAL; 258 259 if (info.index >= vdev->num_irqs) 260 return -EINVAL; 261 262 info.flags = vdev->irqs[info.index].flags; 263 info.count = vdev->irqs[info.index].count; 264 265 return copy_to_user((void __user *)arg, &info, minsz); 266 267 } else if (cmd == VFIO_DEVICE_SET_IRQS) { 268 struct vfio_irq_set hdr; 269 u8 *data = NULL; 270 int ret = 0; 271 272 minsz = offsetofend(struct vfio_irq_set, count); 273 274 if (copy_from_user(&hdr, (void __user *)arg, minsz)) 275 return -EFAULT; 276 277 if (hdr.argsz < minsz) 278 return -EINVAL; 279 280 if (hdr.index >= vdev->num_irqs) 281 return -EINVAL; 282 283 if (hdr.flags & ~(VFIO_IRQ_SET_DATA_TYPE_MASK | 284 VFIO_IRQ_SET_ACTION_TYPE_MASK)) 285 return -EINVAL; 286 287 if (!(hdr.flags & VFIO_IRQ_SET_DATA_NONE)) { 288 size_t size; 289 290 if (hdr.flags & VFIO_IRQ_SET_DATA_BOOL) 291 size = sizeof(uint8_t); 292 else if (hdr.flags & VFIO_IRQ_SET_DATA_EVENTFD) 293 size = sizeof(int32_t); 294 else 295 return -EINVAL; 296 297 if (hdr.argsz - minsz < size) 298 return -EINVAL; 299 300 data = memdup_user((void __user *)(arg + minsz), size); 301 if (IS_ERR(data)) 302 return PTR_ERR(data); 303 } 304 305 mutex_lock(&vdev->igate); 306 307 ret = vfio_platform_set_irqs_ioctl(vdev, hdr.flags, hdr.index, 308 hdr.start, hdr.count, data); 309 mutex_unlock(&vdev->igate); 310 kfree(data); 311 312 return ret; 313 314 } else if (cmd == VFIO_DEVICE_RESET) { 315 if (vdev->reset) 316 return vdev->reset(vdev); 317 else 318 return -EINVAL; 319 } 320 321 return -ENOTTY; 322 } 323 324 static ssize_t vfio_platform_read_mmio(struct vfio_platform_region *reg, 325 char __user *buf, size_t count, 326 loff_t off) 327 { 328 unsigned int done = 0; 329 330 if (!reg->ioaddr) { 331 reg->ioaddr = 332 ioremap_nocache(reg->addr, reg->size); 333 334 if (!reg->ioaddr) 335 return -ENOMEM; 336 } 337 338 while (count) { 339 size_t filled; 340 341 if (count >= 4 && !(off % 4)) { 342 u32 val; 343 344 val = ioread32(reg->ioaddr + off); 345 if (copy_to_user(buf, &val, 4)) 346 goto err; 347 348 filled = 4; 349 } else if (count >= 2 && !(off % 2)) { 350 u16 val; 351 352 val = ioread16(reg->ioaddr + off); 353 if (copy_to_user(buf, &val, 2)) 354 goto err; 355 356 filled = 2; 357 } else { 358 u8 val; 359 360 val = ioread8(reg->ioaddr + off); 361 if (copy_to_user(buf, &val, 1)) 362 goto err; 363 364 filled = 1; 365 } 366 367 368 count -= filled; 369 done += filled; 370 off += filled; 371 buf += filled; 372 } 373 374 return done; 375 err: 376 return -EFAULT; 377 } 378 379 static ssize_t vfio_platform_read(void *device_data, char __user *buf, 380 size_t count, loff_t *ppos) 381 { 382 struct vfio_platform_device *vdev = device_data; 383 unsigned int index = VFIO_PLATFORM_OFFSET_TO_INDEX(*ppos); 384 loff_t off = *ppos & VFIO_PLATFORM_OFFSET_MASK; 385 386 if (index >= vdev->num_regions) 387 return -EINVAL; 388 389 if (!(vdev->regions[index].flags & VFIO_REGION_INFO_FLAG_READ)) 390 return -EINVAL; 391 392 if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_MMIO) 393 return vfio_platform_read_mmio(&vdev->regions[index], 394 buf, count, off); 395 else if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_PIO) 396 return -EINVAL; /* not implemented */ 397 398 return -EINVAL; 399 } 400 401 static ssize_t vfio_platform_write_mmio(struct vfio_platform_region *reg, 402 const char __user *buf, size_t count, 403 loff_t off) 404 { 405 unsigned int done = 0; 406 407 if (!reg->ioaddr) { 408 reg->ioaddr = 409 ioremap_nocache(reg->addr, reg->size); 410 411 if (!reg->ioaddr) 412 return -ENOMEM; 413 } 414 415 while (count) { 416 size_t filled; 417 418 if (count >= 4 && !(off % 4)) { 419 u32 val; 420 421 if (copy_from_user(&val, buf, 4)) 422 goto err; 423 iowrite32(val, reg->ioaddr + off); 424 425 filled = 4; 426 } else if (count >= 2 && !(off % 2)) { 427 u16 val; 428 429 if (copy_from_user(&val, buf, 2)) 430 goto err; 431 iowrite16(val, reg->ioaddr + off); 432 433 filled = 2; 434 } else { 435 u8 val; 436 437 if (copy_from_user(&val, buf, 1)) 438 goto err; 439 iowrite8(val, reg->ioaddr + off); 440 441 filled = 1; 442 } 443 444 count -= filled; 445 done += filled; 446 off += filled; 447 buf += filled; 448 } 449 450 return done; 451 err: 452 return -EFAULT; 453 } 454 455 static ssize_t vfio_platform_write(void *device_data, const char __user *buf, 456 size_t count, loff_t *ppos) 457 { 458 struct vfio_platform_device *vdev = device_data; 459 unsigned int index = VFIO_PLATFORM_OFFSET_TO_INDEX(*ppos); 460 loff_t off = *ppos & VFIO_PLATFORM_OFFSET_MASK; 461 462 if (index >= vdev->num_regions) 463 return -EINVAL; 464 465 if (!(vdev->regions[index].flags & VFIO_REGION_INFO_FLAG_WRITE)) 466 return -EINVAL; 467 468 if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_MMIO) 469 return vfio_platform_write_mmio(&vdev->regions[index], 470 buf, count, off); 471 else if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_PIO) 472 return -EINVAL; /* not implemented */ 473 474 return -EINVAL; 475 } 476 477 static int vfio_platform_mmap_mmio(struct vfio_platform_region region, 478 struct vm_area_struct *vma) 479 { 480 u64 req_len, pgoff, req_start; 481 482 req_len = vma->vm_end - vma->vm_start; 483 pgoff = vma->vm_pgoff & 484 ((1U << (VFIO_PLATFORM_OFFSET_SHIFT - PAGE_SHIFT)) - 1); 485 req_start = pgoff << PAGE_SHIFT; 486 487 if (region.size < PAGE_SIZE || req_start + req_len > region.size) 488 return -EINVAL; 489 490 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 491 vma->vm_pgoff = (region.addr >> PAGE_SHIFT) + pgoff; 492 493 return remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff, 494 req_len, vma->vm_page_prot); 495 } 496 497 static int vfio_platform_mmap(void *device_data, struct vm_area_struct *vma) 498 { 499 struct vfio_platform_device *vdev = device_data; 500 unsigned int index; 501 502 index = vma->vm_pgoff >> (VFIO_PLATFORM_OFFSET_SHIFT - PAGE_SHIFT); 503 504 if (vma->vm_end < vma->vm_start) 505 return -EINVAL; 506 if (!(vma->vm_flags & VM_SHARED)) 507 return -EINVAL; 508 if (index >= vdev->num_regions) 509 return -EINVAL; 510 if (vma->vm_start & ~PAGE_MASK) 511 return -EINVAL; 512 if (vma->vm_end & ~PAGE_MASK) 513 return -EINVAL; 514 515 if (!(vdev->regions[index].flags & VFIO_REGION_INFO_FLAG_MMAP)) 516 return -EINVAL; 517 518 if (!(vdev->regions[index].flags & VFIO_REGION_INFO_FLAG_READ) 519 && (vma->vm_flags & VM_READ)) 520 return -EINVAL; 521 522 if (!(vdev->regions[index].flags & VFIO_REGION_INFO_FLAG_WRITE) 523 && (vma->vm_flags & VM_WRITE)) 524 return -EINVAL; 525 526 vma->vm_private_data = vdev; 527 528 if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_MMIO) 529 return vfio_platform_mmap_mmio(vdev->regions[index], vma); 530 531 else if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_PIO) 532 return -EINVAL; /* not implemented */ 533 534 return -EINVAL; 535 } 536 537 static const struct vfio_device_ops vfio_platform_ops = { 538 .name = "vfio-platform", 539 .open = vfio_platform_open, 540 .release = vfio_platform_release, 541 .ioctl = vfio_platform_ioctl, 542 .read = vfio_platform_read, 543 .write = vfio_platform_write, 544 .mmap = vfio_platform_mmap, 545 }; 546 547 int vfio_platform_probe_common(struct vfio_platform_device *vdev, 548 struct device *dev) 549 { 550 struct iommu_group *group; 551 int ret; 552 553 if (!vdev) 554 return -EINVAL; 555 556 ret = device_property_read_string(dev, "compatible", &vdev->compat); 557 if (ret) { 558 pr_err("VFIO: cannot retrieve compat for %s\n", vdev->name); 559 return -EINVAL; 560 } 561 562 vdev->device = dev; 563 564 group = iommu_group_get(dev); 565 if (!group) { 566 pr_err("VFIO: No IOMMU group for device %s\n", vdev->name); 567 return -EINVAL; 568 } 569 570 ret = vfio_add_group_dev(dev, &vfio_platform_ops, vdev); 571 if (ret) { 572 iommu_group_put(group); 573 return ret; 574 } 575 576 vfio_platform_get_reset(vdev); 577 578 mutex_init(&vdev->igate); 579 580 return 0; 581 } 582 EXPORT_SYMBOL_GPL(vfio_platform_probe_common); 583 584 struct vfio_platform_device *vfio_platform_remove_common(struct device *dev) 585 { 586 struct vfio_platform_device *vdev; 587 588 vdev = vfio_del_group_dev(dev); 589 590 if (vdev) { 591 vfio_platform_put_reset(vdev); 592 iommu_group_put(dev->iommu_group); 593 } 594 595 return vdev; 596 } 597 EXPORT_SYMBOL_GPL(vfio_platform_remove_common); 598 599 void __vfio_platform_register_reset(struct vfio_platform_reset_node *node) 600 { 601 mutex_lock(&driver_lock); 602 list_add(&node->link, &reset_list); 603 mutex_unlock(&driver_lock); 604 } 605 EXPORT_SYMBOL_GPL(__vfio_platform_register_reset); 606 607 void vfio_platform_unregister_reset(const char *compat, 608 vfio_platform_reset_fn_t fn) 609 { 610 struct vfio_platform_reset_node *iter, *temp; 611 612 mutex_lock(&driver_lock); 613 list_for_each_entry_safe(iter, temp, &reset_list, link) { 614 if (!strcmp(iter->compat, compat) && (iter->reset == fn)) { 615 list_del(&iter->link); 616 break; 617 } 618 } 619 620 mutex_unlock(&driver_lock); 621 622 } 623 EXPORT_SYMBOL_GPL(vfio_platform_unregister_reset); 624 625 MODULE_VERSION(DRIVER_VERSION); 626 MODULE_LICENSE("GPL v2"); 627 MODULE_AUTHOR(DRIVER_AUTHOR); 628 MODULE_DESCRIPTION(DRIVER_DESC); 629