drivers/fpga/dfl-afu-main.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for FPGA Accelerated Function Unit (AFU)
   4  *
   5  * Copyright (C) 2017-2018 Intel Corporation, Inc.
   6  *
   7  * Authors:
   8  *   Wu Hao <hao.wu@intel.com>
   9  *   Xiao Guangrong <guangrong.xiao@linux.intel.com>
  10  *   Joseph Grecco <joe.grecco@intel.com>
  11  *   Enno Luebbers <enno.luebbers@intel.com>
  12  *   Tim Whisonant <tim.whisonant@intel.com>
  13  *   Ananda Ravuri <ananda.ravuri@intel.com>
  14  *   Henry Mitchel <henry.mitchel@intel.com>
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/uaccess.h>
  20 #include <linux/fpga-dfl.h>
  21
  22 #include "dfl-afu.h"
  23
  24 /**
  25  * port_enable - enable a port
  26  * @pdev: port platform device.
  27  *
  28  * Enable Port by clear the port soft reset bit, which is set by default.
  29  * The AFU is unable to respond to any MMIO access while in reset.
  30  * port_enable function should only be used after port_disable function.
  31  */
  32 static void port_enable(struct platform_device *pdev)
  33 {
  34         struct dfl_feature_platform_data *pdata = dev_get_platdata(&pdev->dev);
  35         void __iomem *base;
  36         u64 v;
  37
  38         WARN_ON(!pdata->disable_count);
  39
  40         if (--pdata->disable_count != 0)
  41                 return;
  42
  43         base = dfl_get_feature_ioaddr_by_id(&pdev->dev, PORT_FEATURE_ID_HEADER);
  44
  45         /* Clear port soft reset */
  46         v = readq(base + PORT_HDR_CTRL);
  47         v &= ~PORT_CTRL_SFTRST;
  48         writeq(v, base + PORT_HDR_CTRL);
  49 }
  50
  51 #define RST_POLL_INVL 10 /* us */
  52 #define RST_POLL_TIMEOUT 1000 /* us */
  53
  54 /**
  55  * port_disable - disable a port
  56  * @pdev: port platform device.
  57  *
  58  * Disable Port by setting the port soft reset bit, it puts the port into
  59  * reset.
  60  */
  61 static int port_disable(struct platform_device *pdev)
  62 {
  63         struct dfl_feature_platform_data *pdata = dev_get_platdata(&pdev->dev);
  64         void __iomem *base;
  65         u64 v;
  66
  67         if (pdata->disable_count++ != 0)
  68                 return 0;
  69
  70         base = dfl_get_feature_ioaddr_by_id(&pdev->dev, PORT_FEATURE_ID_HEADER);
  71
  72         /* Set port soft reset */
  73         v = readq(base + PORT_HDR_CTRL);
  74         v |= PORT_CTRL_SFTRST;
  75         writeq(v, base + PORT_HDR_CTRL);
  76
  77         /*
  78          * HW sets ack bit to 1 when all outstanding requests have been drained
  79          * on this port and minimum soft reset pulse width has elapsed.
  80          * Driver polls port_soft_reset_ack to determine if reset done by HW.
  81          */
  82         if (readq_poll_timeout(base + PORT_HDR_CTRL, v,
  83                                v & PORT_CTRL_SFTRST_ACK,
  84                                RST_POLL_INVL, RST_POLL_TIMEOUT)) {
  85                 dev_err(&pdev->dev, "timeout, fail to reset device\n");
  86                 return -ETIMEDOUT;
  87         }
  88
  89         return 0;
  90 }
  91
  92 /*
  93  * This function resets the FPGA Port and its accelerator (AFU) by function
  94  * __port_disable and __port_enable (set port soft reset bit and then clear
  95  * it). Userspace can do Port reset at any time, e.g. during DMA or Partial
  96  * Reconfiguration. But it should never cause any system level issue, only
  97  * functional failure (e.g. DMA or PR operation failure) and be recoverable
  98  * from the failure.
  99  *
 100  * Note: the accelerator (AFU) is not accessible when its port is in reset
 101  * (disabled). Any attempts on MMIO access to AFU while in reset, will
 102  * result errors reported via port error reporting sub feature (if present).
 103  */
 104 static int __port_reset(struct platform_device *pdev)
 105 {
 106         int ret;
 107
 108         ret = port_disable(pdev);
 109         if (!ret)
 110                 port_enable(pdev);
 111
 112         return ret;
 113 }
 114
 115 static int port_reset(struct platform_device *pdev)
 116 {
 117         struct dfl_feature_platform_data *pdata = dev_get_platdata(&pdev->dev);
 118         int ret;
 119
 120         mutex_lock(&pdata->lock);
 121         ret = __port_reset(pdev);
 122         mutex_unlock(&pdata->lock);
 123
 124         return ret;
 125 }
 126
 127 static int port_get_id(struct platform_device *pdev)
 128 {
 129         void __iomem *base;
 130
 131         base = dfl_get_feature_ioaddr_by_id(&pdev->dev, PORT_FEATURE_ID_HEADER);
 132
 133         return FIELD_GET(PORT_CAP_PORT_NUM, readq(base + PORT_HDR_CAP));
 134 }
 135
 136 static ssize_t
 137 id_show(struct device *dev, struct device_attribute *attr, char *buf)
 138 {
 139         int id = port_get_id(to_platform_device(dev));
 140
 141         return scnprintf(buf, PAGE_SIZE, "%d\n", id);
 142 }
 143 static DEVICE_ATTR_RO(id);
 144
 145 static const struct attribute *port_hdr_attrs[] = {
 146         &dev_attr_id.attr,
 147         NULL,
 148 };
 149
 150 static int port_hdr_init(struct platform_device *pdev,
 151                          struct dfl_feature *feature)
 152 {
 153         dev_dbg(&pdev->dev, "PORT HDR Init.\n");
 154
 155         port_reset(pdev);
 156
 157         return sysfs_create_files(&pdev->dev.kobj, port_hdr_attrs);
 158 }
 159
 160 static void port_hdr_uinit(struct platform_device *pdev,
 161                            struct dfl_feature *feature)
 162 {
 163         dev_dbg(&pdev->dev, "PORT HDR UInit.\n");
 164
 165         sysfs_remove_files(&pdev->dev.kobj, port_hdr_attrs);
 166 }
 167
 168 static long
 169 port_hdr_ioctl(struct platform_device *pdev, struct dfl_feature *feature,
 170                unsigned int cmd, unsigned long arg)
 171 {
 172         long ret;
 173
 174         switch (cmd) {
 175         case DFL_FPGA_PORT_RESET:
 176                 if (!arg)
 177                         ret = port_reset(pdev);
 178                 else
 179                         ret = -EINVAL;
 180                 break;
 181         default:
 182                 dev_dbg(&pdev->dev, "%x cmd not handled", cmd);
 183                 ret = -ENODEV;
 184         }
 185
 186         return ret;
 187 }
 188
 189 static const struct dfl_feature_ops port_hdr_ops = {
 190         .init = port_hdr_init,
 191         .uinit = port_hdr_uinit,
 192         .ioctl = port_hdr_ioctl,
 193 };
 194
 195 static ssize_t
 196 afu_id_show(struct device *dev, struct device_attribute *attr, char *buf)
 197 {
 198         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
 199         void __iomem *base;
 200         u64 guidl, guidh;
 201
 202         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_AFU);
 203
 204         mutex_lock(&pdata->lock);
 205         if (pdata->disable_count) {
 206                 mutex_unlock(&pdata->lock);
 207                 return -EBUSY;
 208         }
 209
 210         guidl = readq(base + GUID_L);
 211         guidh = readq(base + GUID_H);
 212         mutex_unlock(&pdata->lock);
 213
 214         return scnprintf(buf, PAGE_SIZE, "%016llx%016llx\n", guidh, guidl);
 215 }
 216 static DEVICE_ATTR_RO(afu_id);
 217
 218 static const struct attribute *port_afu_attrs[] = {
 219         &dev_attr_afu_id.attr,
 220         NULL
 221 };
 222
 223 static int port_afu_init(struct platform_device *pdev,
 224                          struct dfl_feature *feature)
 225 {
 226         struct resource *res = &pdev->resource[feature->resource_index];
 227         int ret;
 228
 229         dev_dbg(&pdev->dev, "PORT AFU Init.\n");
 230
 231         ret = afu_mmio_region_add(dev_get_platdata(&pdev->dev),
 232                                   DFL_PORT_REGION_INDEX_AFU, resource_size(res),
 233                                   res->start, DFL_PORT_REGION_READ |
 234                                   DFL_PORT_REGION_WRITE | DFL_PORT_REGION_MMAP);
 235         if (ret)
 236                 return ret;
 237
 238         return sysfs_create_files(&pdev->dev.kobj, port_afu_attrs);
 239 }
 240
 241 static void port_afu_uinit(struct platform_device *pdev,
 242                            struct dfl_feature *feature)
 243 {
 244         dev_dbg(&pdev->dev, "PORT AFU UInit.\n");
 245
 246         sysfs_remove_files(&pdev->dev.kobj, port_afu_attrs);
 247 }
 248
 249 static const struct dfl_feature_ops port_afu_ops = {
 250         .init = port_afu_init,
 251         .uinit = port_afu_uinit,
 252 };
 253
 254 static struct dfl_feature_driver port_feature_drvs[] = {
 255         {
 256                 .id = PORT_FEATURE_ID_HEADER,
 257                 .ops = &port_hdr_ops,
 258         },
 259         {
 260                 .id = PORT_FEATURE_ID_AFU,
 261                 .ops = &port_afu_ops,
 262         },
 263         {
 264                 .ops = NULL,
 265         }
 266 };
 267
 268 static int afu_open(struct inode *inode, struct file *filp)
 269 {
 270         struct platform_device *fdev = dfl_fpga_inode_to_feature_dev(inode);
 271         struct dfl_feature_platform_data *pdata;
 272         int ret;
 273
 274         pdata = dev_get_platdata(&fdev->dev);
 275         if (WARN_ON(!pdata))
 276                 return -ENODEV;
 277
 278         ret = dfl_feature_dev_use_begin(pdata);
 279         if (ret)
 280                 return ret;
 281
 282         dev_dbg(&fdev->dev, "Device File Open\n");
 283         filp->private_data = fdev;
 284
 285         return 0;
 286 }
 287
 288 static int afu_release(struct inode *inode, struct file *filp)
 289 {
 290         struct platform_device *pdev = filp->private_data;
 291         struct dfl_feature_platform_data *pdata;
 292
 293         dev_dbg(&pdev->dev, "Device File Release\n");
 294
 295         pdata = dev_get_platdata(&pdev->dev);
 296
 297         mutex_lock(&pdata->lock);
 298         __port_reset(pdev);
 299         afu_dma_region_destroy(pdata);
 300         mutex_unlock(&pdata->lock);
 301
 302         dfl_feature_dev_use_end(pdata);
 303
 304         return 0;
 305 }
 306
 307 static long afu_ioctl_check_extension(struct dfl_feature_platform_data *pdata,
 308                                       unsigned long arg)
 309 {
 310         /* No extension support for now */
 311         return 0;
 312 }
 313
 314 static long
 315 afu_ioctl_get_info(struct dfl_feature_platform_data *pdata, void __user *arg)
 316 {
 317         struct dfl_fpga_port_info info;
 318         struct dfl_afu *afu;
 319         unsigned long minsz;
 320
 321         minsz = offsetofend(struct dfl_fpga_port_info, num_umsgs);
 322
 323         if (copy_from_user(&info, arg, minsz))
 324                 return -EFAULT;
 325
 326         if (info.argsz < minsz)
 327                 return -EINVAL;
 328
 329         mutex_lock(&pdata->lock);
 330         afu = dfl_fpga_pdata_get_private(pdata);
 331         info.flags = 0;
 332         info.num_regions = afu->num_regions;
 333         info.num_umsgs = afu->num_umsgs;
 334         mutex_unlock(&pdata->lock);
 335
 336         if (copy_to_user(arg, &info, sizeof(info)))
 337                 return -EFAULT;
 338
 339         return 0;
 340 }
 341
 342 static long afu_ioctl_get_region_info(struct dfl_feature_platform_data *pdata,
 343                                       void __user *arg)
 344 {
 345         struct dfl_fpga_port_region_info rinfo;
 346         struct dfl_afu_mmio_region region;
 347         unsigned long minsz;
 348         long ret;
 349
 350         minsz = offsetofend(struct dfl_fpga_port_region_info, offset);
 351
 352         if (copy_from_user(&rinfo, arg, minsz))
 353                 return -EFAULT;
 354
 355         if (rinfo.argsz < minsz || rinfo.padding)
 356                 return -EINVAL;
 357
 358         ret = afu_mmio_region_get_by_index(pdata, rinfo.index, &region);
 359         if (ret)
 360                 return ret;
 361
 362         rinfo.flags = region.flags;
 363         rinfo.size = region.size;
 364         rinfo.offset = region.offset;
 365
 366         if (copy_to_user(arg, &rinfo, sizeof(rinfo)))
 367                 return -EFAULT;
 368
 369         return 0;
 370 }
 371
 372 static long
 373 afu_ioctl_dma_map(struct dfl_feature_platform_data *pdata, void __user *arg)
 374 {
 375         struct dfl_fpga_port_dma_map map;
 376         unsigned long minsz;
 377         long ret;
 378
 379         minsz = offsetofend(struct dfl_fpga_port_dma_map, iova);
 380
 381         if (copy_from_user(&map, arg, minsz))
 382                 return -EFAULT;
 383
 384         if (map.argsz < minsz || map.flags)
 385                 return -EINVAL;
 386
 387         ret = afu_dma_map_region(pdata, map.user_addr, map.length, &map.iova);
 388         if (ret)
 389                 return ret;
 390
 391         if (copy_to_user(arg, &map, sizeof(map))) {
 392                 afu_dma_unmap_region(pdata, map.iova);
 393                 return -EFAULT;
 394         }
 395
 396         dev_dbg(&pdata->dev->dev, "dma map: ua=%llx, len=%llx, iova=%llx\n",
 397                 (unsigned long long)map.user_addr,
 398                 (unsigned long long)map.length,
 399                 (unsigned long long)map.iova);
 400
 401         return 0;
 402 }
 403
 404 static long
 405 afu_ioctl_dma_unmap(struct dfl_feature_platform_data *pdata, void __user *arg)
 406 {
 407         struct dfl_fpga_port_dma_unmap unmap;
 408         unsigned long minsz;
 409
 410         minsz = offsetofend(struct dfl_fpga_port_dma_unmap, iova);
 411
 412         if (copy_from_user(&unmap, arg, minsz))
 413                 return -EFAULT;
 414
 415         if (unmap.argsz < minsz || unmap.flags)
 416                 return -EINVAL;
 417
 418         return afu_dma_unmap_region(pdata, unmap.iova);
 419 }
 420
 421 static long afu_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 422 {
 423         struct platform_device *pdev = filp->private_data;
 424         struct dfl_feature_platform_data *pdata;
 425         struct dfl_feature *f;
 426         long ret;
 427
 428         dev_dbg(&pdev->dev, "%s cmd 0x%x\n", __func__, cmd);
 429
 430         pdata = dev_get_platdata(&pdev->dev);
 431
 432         switch (cmd) {
 433         case DFL_FPGA_GET_API_VERSION:
 434                 return DFL_FPGA_API_VERSION;
 435         case DFL_FPGA_CHECK_EXTENSION:
 436                 return afu_ioctl_check_extension(pdata, arg);
 437         case DFL_FPGA_PORT_GET_INFO:
 438                 return afu_ioctl_get_info(pdata, (void __user *)arg);
 439         case DFL_FPGA_PORT_GET_REGION_INFO:
 440                 return afu_ioctl_get_region_info(pdata, (void __user *)arg);
 441         case DFL_FPGA_PORT_DMA_MAP:
 442                 return afu_ioctl_dma_map(pdata, (void __user *)arg);
 443         case DFL_FPGA_PORT_DMA_UNMAP:
 444                 return afu_ioctl_dma_unmap(pdata, (void __user *)arg);
 445         default:
 446                 /*
 447                  * Let sub-feature's ioctl function to handle the cmd
 448                  * Sub-feature's ioctl returns -ENODEV when cmd is not
 449                  * handled in this sub feature, and returns 0 and other
 450                  * error code if cmd is handled.
 451                  */
 452                 dfl_fpga_dev_for_each_feature(pdata, f)
 453                         if (f->ops && f->ops->ioctl) {
 454                                 ret = f->ops->ioctl(pdev, f, cmd, arg);
 455                                 if (ret != -ENODEV)
 456                                         return ret;
 457                         }
 458         }
 459
 460         return -EINVAL;
 461 }
 462
 463 static int afu_mmap(struct file *filp, struct vm_area_struct *vma)
 464 {
 465         struct platform_device *pdev = filp->private_data;
 466         struct dfl_feature_platform_data *pdata;
 467         u64 size = vma->vm_end - vma->vm_start;
 468         struct dfl_afu_mmio_region region;
 469         u64 offset;
 470         int ret;
 471
 472         if (!(vma->vm_flags & VM_SHARED))
 473                 return -EINVAL;
 474
 475         pdata = dev_get_platdata(&pdev->dev);
 476
 477         offset = vma->vm_pgoff << PAGE_SHIFT;
 478         ret = afu_mmio_region_get_by_offset(pdata, offset, size, &region);
 479         if (ret)
 480                 return ret;
 481
 482         if (!(region.flags & DFL_PORT_REGION_MMAP))
 483                 return -EINVAL;
 484
 485         if ((vma->vm_flags & VM_READ) && !(region.flags & DFL_PORT_REGION_READ))
 486                 return -EPERM;
 487
 488         if ((vma->vm_flags & VM_WRITE) &&
 489             !(region.flags & DFL_PORT_REGION_WRITE))
 490                 return -EPERM;
 491
 492         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 493
 494         return remap_pfn_range(vma, vma->vm_start,
 495                         (region.phys + (offset - region.offset)) >> PAGE_SHIFT,
 496                         size, vma->vm_page_prot);
 497 }
 498
 499 static const struct file_operations afu_fops = {
 500         .owner = THIS_MODULE,
 501         .open = afu_open,
 502         .release = afu_release,
 503         .unlocked_ioctl = afu_ioctl,
 504         .mmap = afu_mmap,
 505 };
 506
 507 static int afu_dev_init(struct platform_device *pdev)
 508 {
 509         struct dfl_feature_platform_data *pdata = dev_get_platdata(&pdev->dev);
 510         struct dfl_afu *afu;
 511
 512         afu = devm_kzalloc(&pdev->dev, sizeof(*afu), GFP_KERNEL);
 513         if (!afu)
 514                 return -ENOMEM;
 515
 516         afu->pdata = pdata;
 517
 518         mutex_lock(&pdata->lock);
 519         dfl_fpga_pdata_set_private(pdata, afu);
 520         afu_mmio_region_init(pdata);
 521         afu_dma_region_init(pdata);
 522         mutex_unlock(&pdata->lock);
 523
 524         return 0;
 525 }
 526
 527 static int afu_dev_destroy(struct platform_device *pdev)
 528 {
 529         struct dfl_feature_platform_data *pdata = dev_get_platdata(&pdev->dev);
 530         struct dfl_afu *afu;
 531
 532         mutex_lock(&pdata->lock);
 533         afu = dfl_fpga_pdata_get_private(pdata);
 534         afu_mmio_region_destroy(pdata);
 535         afu_dma_region_destroy(pdata);
 536         dfl_fpga_pdata_set_private(pdata, NULL);
 537         mutex_unlock(&pdata->lock);
 538
 539         return 0;
 540 }
 541
 542 static int port_enable_set(struct platform_device *pdev, bool enable)
 543 {
 544         struct dfl_feature_platform_data *pdata = dev_get_platdata(&pdev->dev);
 545         int ret = 0;
 546
 547         mutex_lock(&pdata->lock);
 548         if (enable)
 549                 port_enable(pdev);
 550         else
 551                 ret = port_disable(pdev);
 552         mutex_unlock(&pdata->lock);
 553
 554         return ret;
 555 }
 556
 557 static struct dfl_fpga_port_ops afu_port_ops = {
 558         .name = DFL_FPGA_FEATURE_DEV_PORT,
 559         .owner = THIS_MODULE,
 560         .get_id = port_get_id,
 561         .enable_set = port_enable_set,
 562 };
 563
 564 static int afu_probe(struct platform_device *pdev)
 565 {
 566         int ret;
 567
 568         dev_dbg(&pdev->dev, "%s\n", __func__);
 569
 570         ret = afu_dev_init(pdev);
 571         if (ret)
 572                 goto exit;
 573
 574         ret = dfl_fpga_dev_feature_init(pdev, port_feature_drvs);
 575         if (ret)
 576                 goto dev_destroy;
 577
 578         ret = dfl_fpga_dev_ops_register(pdev, &afu_fops, THIS_MODULE);
 579         if (ret) {
 580                 dfl_fpga_dev_feature_uinit(pdev);
 581                 goto dev_destroy;
 582         }
 583
 584         return 0;
 585
 586 dev_destroy:
 587         afu_dev_destroy(pdev);
 588 exit:
 589         return ret;
 590 }
 591
 592 static int afu_remove(struct platform_device *pdev)
 593 {
 594         dev_dbg(&pdev->dev, "%s\n", __func__);
 595
 596         dfl_fpga_dev_ops_unregister(pdev);
 597         dfl_fpga_dev_feature_uinit(pdev);
 598         afu_dev_destroy(pdev);
 599
 600         return 0;
 601 }
 602
 603 static struct platform_driver afu_driver = {
 604         .driver = {
 605                 .name    = DFL_FPGA_FEATURE_DEV_PORT,
 606         },
 607         .probe   = afu_probe,
 608         .remove  = afu_remove,
 609 };
 610
 611 static int __init afu_init(void)
 612 {
 613         int ret;
 614
 615         dfl_fpga_port_ops_add(&afu_port_ops);
 616
 617         ret = platform_driver_register(&afu_driver);
 618         if (ret)
 619                 dfl_fpga_port_ops_del(&afu_port_ops);
 620
 621         return ret;
 622 }
 623
 624 static void __exit afu_exit(void)
 625 {
 626         platform_driver_unregister(&afu_driver);
 627
 628         dfl_fpga_port_ops_del(&afu_port_ops);
 629 }
 630
 631 module_init(afu_init);
 632 module_exit(afu_exit);
 633
 634 MODULE_DESCRIPTION("FPGA Accelerated Function Unit driver");
 635 MODULE_AUTHOR("Intel Corporation");
 636 MODULE_LICENSE("GPL v2");
 637 MODULE_ALIAS("platform:dfl-port");