arch/powerpc/platforms/powernv/vas-api.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * VAS user space API for its accelerators (Only NX-GZIP is supported now)
   4  * Copyright (C) 2019 Haren Myneni, IBM Corp
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/device.h>
   9 #include <linux/cdev.h>
  10 #include <linux/fs.h>
  11 #include <linux/slab.h>
  12 #include <linux/uaccess.h>
  13 #include <asm/vas.h>
  14 #include <uapi/asm/vas-api.h>
  15 #include "vas.h"
  16
  17 /*
  18  * The driver creates the device node that can be used as follows:
  19  * For NX-GZIP
  20  *
  21  *      fd = open("/dev/crypto/nx-gzip", O_RDWR);
  22  *      rc = ioctl(fd, VAS_TX_WIN_OPEN, &attr);
  23  *      paste_addr = mmap(NULL, PAGE_SIZE, prot, MAP_SHARED, fd, 0ULL).
  24  *      vas_copy(&crb, 0, 1);
  25  *      vas_paste(paste_addr, 0, 1);
  26  *      close(fd) or exit process to close window.
  27  *
  28  * where "vas_copy" and "vas_paste" are defined in copy-paste.h.
  29  * copy/paste returns to the user space directly. So refer NX hardware
  30  * documententation for exact copy/paste usage and completion / error
  31  * conditions.
  32  */
  33
  34 /*
  35  * Wrapper object for the nx-gzip device - there is just one instance of
  36  * this node for the whole system.
  37  */
  38 static struct coproc_dev {
  39         struct cdev cdev;
  40         struct device *device;
  41         char *name;
  42         dev_t devt;
  43         struct class *class;
  44         enum vas_cop_type cop_type;
  45 } coproc_device;
  46
  47 struct coproc_instance {
  48         struct coproc_dev *coproc;
  49         struct vas_window *txwin;
  50 };
  51
  52 static char *coproc_devnode(struct device *dev, umode_t *mode)
  53 {
  54         return kasprintf(GFP_KERNEL, "crypto/%s", dev_name(dev));
  55 }
  56
  57 static int coproc_open(struct inode *inode, struct file *fp)
  58 {
  59         struct coproc_instance *cp_inst;
  60
  61         cp_inst = kzalloc(sizeof(*cp_inst), GFP_KERNEL);
  62         if (!cp_inst)
  63                 return -ENOMEM;
  64
  65         cp_inst->coproc = container_of(inode->i_cdev, struct coproc_dev,
  66                                         cdev);
  67         fp->private_data = cp_inst;
  68
  69         return 0;
  70 }
  71
  72 static int coproc_ioc_tx_win_open(struct file *fp, unsigned long arg)
  73 {
  74         void __user *uptr = (void __user *)arg;
  75         struct vas_tx_win_attr txattr = {};
  76         struct vas_tx_win_open_attr uattr;
  77         struct coproc_instance *cp_inst;
  78         struct vas_window *txwin;
  79         int rc, vasid;
  80
  81         cp_inst = fp->private_data;
  82
  83         /*
  84          * One window for file descriptor
  85          */
  86         if (cp_inst->txwin)
  87                 return -EEXIST;
  88
  89         rc = copy_from_user(&uattr, uptr, sizeof(uattr));
  90         if (rc) {
  91                 pr_err("%s(): copy_from_user() returns %d\n", __func__, rc);
  92                 return -EFAULT;
  93         }
  94
  95         if (uattr.version != 1) {
  96                 pr_err("Invalid version\n");
  97                 return -EINVAL;
  98         }
  99
 100         vasid = uattr.vas_id;
 101
 102         vas_init_tx_win_attr(&txattr, cp_inst->coproc->cop_type);
 103
 104         txattr.lpid = mfspr(SPRN_LPID);
 105         txattr.pidr = mfspr(SPRN_PID);
 106         txattr.user_win = true;
 107         txattr.rsvd_txbuf_count = false;
 108         txattr.pswid = false;
 109
 110         pr_devel("Pid %d: Opening txwin, PIDR %ld\n", txattr.pidr,
 111                                 mfspr(SPRN_PID));
 112
 113         txwin = vas_tx_win_open(vasid, cp_inst->coproc->cop_type, &txattr);
 114         if (IS_ERR(txwin)) {
 115                 pr_err("%s() vas_tx_win_open() failed, %ld\n", __func__,
 116                                         PTR_ERR(txwin));
 117                 return PTR_ERR(txwin);
 118         }
 119
 120         cp_inst->txwin = txwin;
 121
 122         return 0;
 123 }
 124
 125 static int coproc_release(struct inode *inode, struct file *fp)
 126 {
 127         struct coproc_instance *cp_inst = fp->private_data;
 128
 129         if (cp_inst->txwin) {
 130                 vas_win_close(cp_inst->txwin);
 131                 cp_inst->txwin = NULL;
 132         }
 133
 134         kfree(cp_inst);
 135         fp->private_data = NULL;
 136
 137         /*
 138          * We don't know here if user has other receive windows
 139          * open, so we can't really call clear_thread_tidr().
 140          * So, once the process calls set_thread_tidr(), the
 141          * TIDR value sticks around until process exits, resulting
 142          * in an extra copy in restore_sprs().
 143          */
 144
 145         return 0;
 146 }
 147
 148 static int coproc_mmap(struct file *fp, struct vm_area_struct *vma)
 149 {
 150         struct coproc_instance *cp_inst = fp->private_data;
 151         struct vas_window *txwin;
 152         unsigned long pfn;
 153         u64 paste_addr;
 154         pgprot_t prot;
 155         int rc;
 156
 157         txwin = cp_inst->txwin;
 158
 159         if ((vma->vm_end - vma->vm_start) > PAGE_SIZE) {
 160                 pr_debug("%s(): size 0x%zx, PAGE_SIZE 0x%zx\n", __func__,
 161                                 (vma->vm_end - vma->vm_start), PAGE_SIZE);
 162                 return -EINVAL;
 163         }
 164
 165         /* Ensure instance has an open send window */
 166         if (!txwin) {
 167                 pr_err("%s(): No send window open?\n", __func__);
 168                 return -EINVAL;
 169         }
 170
 171         vas_win_paste_addr(txwin, &paste_addr, NULL);
 172         pfn = paste_addr >> PAGE_SHIFT;
 173
 174         /* flags, page_prot from cxl_mmap(), except we want cachable */
 175         vma->vm_flags |= VM_IO | VM_PFNMAP;
 176         vma->vm_page_prot = pgprot_cached(vma->vm_page_prot);
 177
 178         prot = __pgprot(pgprot_val(vma->vm_page_prot) | _PAGE_DIRTY);
 179
 180         rc = remap_pfn_range(vma, vma->vm_start, pfn + vma->vm_pgoff,
 181                         vma->vm_end - vma->vm_start, prot);
 182
 183         pr_devel("%s(): paste addr %llx at %lx, rc %d\n", __func__,
 184                         paste_addr, vma->vm_start, rc);
 185
 186         return rc;
 187 }
 188
 189 static long coproc_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
 190 {
 191         switch (cmd) {
 192         case VAS_TX_WIN_OPEN:
 193                 return coproc_ioc_tx_win_open(fp, arg);
 194         default:
 195                 return -EINVAL;
 196         }
 197 }
 198
 199 static struct file_operations coproc_fops = {
 200         .open = coproc_open,
 201         .release = coproc_release,
 202         .mmap = coproc_mmap,
 203         .unlocked_ioctl = coproc_ioctl,
 204 };
 205
 206 /*
 207  * Supporting only nx-gzip coprocessor type now, but this API code
 208  * extended to other coprocessor types later.
 209  */
 210 int vas_register_coproc_api(struct module *mod, enum vas_cop_type cop_type,
 211                                 const char *name)
 212 {
 213         int rc = -EINVAL;
 214         dev_t devno;
 215
 216         rc = alloc_chrdev_region(&coproc_device.devt, 1, 1, name);
 217         if (rc) {
 218                 pr_err("Unable to allocate coproc major number: %i\n", rc);
 219                 return rc;
 220         }
 221
 222         pr_devel("%s device allocated, dev [%i,%i]\n", name,
 223                         MAJOR(coproc_device.devt), MINOR(coproc_device.devt));
 224
 225         coproc_device.class = class_create(mod, name);
 226         if (IS_ERR(coproc_device.class)) {
 227                 rc = PTR_ERR(coproc_device.class);
 228                 pr_err("Unable to create %s class %d\n", name, rc);
 229                 goto err_class;
 230         }
 231         coproc_device.class->devnode = coproc_devnode;
 232         coproc_device.cop_type = cop_type;
 233
 234         coproc_fops.owner = mod;
 235         cdev_init(&coproc_device.cdev, &coproc_fops);
 236
 237         devno = MKDEV(MAJOR(coproc_device.devt), 0);
 238         rc = cdev_add(&coproc_device.cdev, devno, 1);
 239         if (rc) {
 240                 pr_err("cdev_add() failed %d\n", rc);
 241                 goto err_cdev;
 242         }
 243
 244         coproc_device.device = device_create(coproc_device.class, NULL,
 245                         devno, NULL, name, MINOR(devno));
 246         if (IS_ERR(coproc_device.device)) {
 247                 rc = PTR_ERR(coproc_device.device);
 248                 pr_err("Unable to create coproc-%d %d\n", MINOR(devno), rc);
 249                 goto err;
 250         }
 251
 252         pr_devel("%s: Added dev [%d,%d]\n", __func__, MAJOR(devno),
 253                         MINOR(devno));
 254
 255         return 0;
 256
 257 err:
 258         cdev_del(&coproc_device.cdev);
 259 err_cdev:
 260         class_destroy(coproc_device.class);
 261 err_class:
 262         unregister_chrdev_region(coproc_device.devt, 1);
 263         return rc;
 264 }
 265 EXPORT_SYMBOL_GPL(vas_register_coproc_api);
 266
 267 void vas_unregister_coproc_api(void)
 268 {
 269         dev_t devno;
 270
 271         cdev_del(&coproc_device.cdev);
 272         devno = MKDEV(MAJOR(coproc_device.devt), 0);
 273         device_destroy(coproc_device.class, devno);
 274
 275         class_destroy(coproc_device.class);
 276         unregister_chrdev_region(coproc_device.devt, 1);
 277 }
 278 EXPORT_SYMBOL_GPL(vas_unregister_coproc_api);