drivers/misc/cxl/api.c

   1 /*
   2  * Copyright 2014 IBM Corp.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version
   7  * 2 of the License, or (at your option) any later version.
   8  */
   9
  10 #include <linux/pci.h>
  11 #include <linux/slab.h>
  12 #include <linux/anon_inodes.h>
  13 #include <linux/file.h>
  14 #include <misc/cxl.h>
  15 #include <linux/fs.h>
  16 #include <asm/pnv-pci.h>
  17 #include <linux/msi.h>
  18
  19 #include "cxl.h"
  20
  21 struct cxl_context *cxl_dev_context_init(struct pci_dev *dev)
  22 {
  23         struct address_space *mapping;
  24         struct cxl_afu *afu;
  25         struct cxl_context  *ctx;
  26         int rc;
  27
  28         afu = cxl_pci_to_afu(dev);
  29         if (IS_ERR(afu))
  30                 return ERR_CAST(afu);
  31
  32         ctx = cxl_context_alloc();
  33         if (IS_ERR(ctx)) {
  34                 rc = PTR_ERR(ctx);
  35                 goto err_dev;
  36         }
  37
  38         ctx->kernelapi = true;
  39
  40         /*
  41          * Make our own address space since we won't have one from the
  42          * filesystem like the user api has, and even if we do associate a file
  43          * with this context we don't want to use the global anonymous inode's
  44          * address space as that can invalidate unrelated users:
  45          */
  46         mapping = kmalloc(sizeof(struct address_space), GFP_KERNEL);
  47         if (!mapping) {
  48                 rc = -ENOMEM;
  49                 goto err_ctx;
  50         }
  51         address_space_init_once(mapping);
  52
  53         /* Make it a slave context.  We can promote it later? */
  54         rc = cxl_context_init(ctx, afu, false, mapping);
  55         if (rc)
  56                 goto err_mapping;
  57
  58         return ctx;
  59
  60 err_mapping:
  61         kfree(mapping);
  62 err_ctx:
  63         kfree(ctx);
  64 err_dev:
  65         return ERR_PTR(rc);
  66 }
  67 EXPORT_SYMBOL_GPL(cxl_dev_context_init);
  68
  69 struct cxl_context *cxl_get_context(struct pci_dev *dev)
  70 {
  71         return dev->dev.archdata.cxl_ctx;
  72 }
  73 EXPORT_SYMBOL_GPL(cxl_get_context);
  74
  75 int cxl_release_context(struct cxl_context *ctx)
  76 {
  77         if (ctx->status >= STARTED)
  78                 return -EBUSY;
  79
  80         cxl_context_free(ctx);
  81
  82         return 0;
  83 }
  84 EXPORT_SYMBOL_GPL(cxl_release_context);
  85
  86 static irq_hw_number_t cxl_find_afu_irq(struct cxl_context *ctx, int num)
  87 {
  88         __u16 range;
  89         int r;
  90
  91         for (r = 0; r < CXL_IRQ_RANGES; r++) {
  92                 range = ctx->irqs.range[r];
  93                 if (num < range) {
  94                         return ctx->irqs.offset[r] + num;
  95                 }
  96                 num -= range;
  97         }
  98         return 0;
  99 }
 100
 101 int _cxl_next_msi_hwirq(struct pci_dev *pdev, struct cxl_context **ctx, int *afu_irq)
 102 {
 103         if (*ctx == NULL || *afu_irq == 0) {
 104                 *afu_irq = 1;
 105                 *ctx = cxl_get_context(pdev);
 106         } else {
 107                 (*afu_irq)++;
 108                 if (*afu_irq > cxl_get_max_irqs_per_process(pdev)) {
 109                         *ctx = list_next_entry(*ctx, extra_irq_contexts);
 110                         *afu_irq = 1;
 111                 }
 112         }
 113         return cxl_find_afu_irq(*ctx, *afu_irq);
 114 }
 115 /* Exported via cxl_base */
 116
 117 int cxl_set_priv(struct cxl_context *ctx, void *priv)
 118 {
 119         if (!ctx)
 120                 return -EINVAL;
 121
 122         ctx->priv = priv;
 123
 124         return 0;
 125 }
 126 EXPORT_SYMBOL_GPL(cxl_set_priv);
 127
 128 void *cxl_get_priv(struct cxl_context *ctx)
 129 {
 130         if (!ctx)
 131                 return ERR_PTR(-EINVAL);
 132
 133         return ctx->priv;
 134 }
 135 EXPORT_SYMBOL_GPL(cxl_get_priv);
 136
 137 int cxl_allocate_afu_irqs(struct cxl_context *ctx, int num)
 138 {
 139         int res;
 140         irq_hw_number_t hwirq;
 141
 142         if (num == 0)
 143                 num = ctx->afu->pp_irqs;
 144         res = afu_allocate_irqs(ctx, num);
 145         if (res)
 146                 return res;
 147
 148         if (!cpu_has_feature(CPU_FTR_HVMODE)) {
 149                 /* In a guest, the PSL interrupt is not multiplexed. It was
 150                  * allocated above, and we need to set its handler
 151                  */
 152                 hwirq = cxl_find_afu_irq(ctx, 0);
 153                 if (hwirq)
 154                         cxl_map_irq(ctx->afu->adapter, hwirq, cxl_ops->psl_interrupt, ctx, "psl");
 155         }
 156
 157         if (ctx->status == STARTED) {
 158                 if (cxl_ops->update_ivtes)
 159                         cxl_ops->update_ivtes(ctx);
 160                 else WARN(1, "BUG: cxl_allocate_afu_irqs must be called prior to starting the context on this platform\n");
 161         }
 162
 163         return res;
 164 }
 165 EXPORT_SYMBOL_GPL(cxl_allocate_afu_irqs);
 166
 167 void cxl_free_afu_irqs(struct cxl_context *ctx)
 168 {
 169         irq_hw_number_t hwirq;
 170         unsigned int virq;
 171
 172         if (!cpu_has_feature(CPU_FTR_HVMODE)) {
 173                 hwirq = cxl_find_afu_irq(ctx, 0);
 174                 if (hwirq) {
 175                         virq = irq_find_mapping(NULL, hwirq);
 176                         if (virq)
 177                                 cxl_unmap_irq(virq, ctx);
 178                 }
 179         }
 180         afu_irq_name_free(ctx);
 181         cxl_ops->release_irq_ranges(&ctx->irqs, ctx->afu->adapter);
 182 }
 183 EXPORT_SYMBOL_GPL(cxl_free_afu_irqs);
 184
 185 int cxl_map_afu_irq(struct cxl_context *ctx, int num,
 186                     irq_handler_t handler, void *cookie, char *name)
 187 {
 188         irq_hw_number_t hwirq;
 189
 190         /*
 191          * Find interrupt we are to register.
 192          */
 193         hwirq = cxl_find_afu_irq(ctx, num);
 194         if (!hwirq)
 195                 return -ENOENT;
 196
 197         return cxl_map_irq(ctx->afu->adapter, hwirq, handler, cookie, name);
 198 }
 199 EXPORT_SYMBOL_GPL(cxl_map_afu_irq);
 200
 201 void cxl_unmap_afu_irq(struct cxl_context *ctx, int num, void *cookie)
 202 {
 203         irq_hw_number_t hwirq;
 204         unsigned int virq;
 205
 206         hwirq = cxl_find_afu_irq(ctx, num);
 207         if (!hwirq)
 208                 return;
 209
 210         virq = irq_find_mapping(NULL, hwirq);
 211         if (virq)
 212                 cxl_unmap_irq(virq, cookie);
 213 }
 214 EXPORT_SYMBOL_GPL(cxl_unmap_afu_irq);
 215
 216 /*
 217  * Start a context
 218  * Code here similar to afu_ioctl_start_work().
 219  */
 220 int cxl_start_context(struct cxl_context *ctx, u64 wed,
 221                       struct task_struct *task)
 222 {
 223         int rc = 0;
 224         bool kernel = true;
 225
 226         pr_devel("%s: pe: %i\n", __func__, ctx->pe);
 227
 228         mutex_lock(&ctx->status_mutex);
 229         if (ctx->status == STARTED)
 230                 goto out; /* already started */
 231
 232         /*
 233          * Increment the mapped context count for adapter. This also checks
 234          * if adapter_context_lock is taken.
 235          */
 236         rc = cxl_adapter_context_get(ctx->afu->adapter);
 237         if (rc)
 238                 goto out;
 239
 240         if (task) {
 241                 ctx->pid = get_task_pid(task, PIDTYPE_PID);
 242                 ctx->glpid = get_task_pid(task->group_leader, PIDTYPE_PID);
 243                 kernel = false;
 244                 ctx->real_mode = false;
 245         }
 246
 247         cxl_ctx_get();
 248
 249         if ((rc = cxl_ops->attach_process(ctx, kernel, wed, 0))) {
 250                 put_pid(ctx->pid);
 251                 cxl_adapter_context_put(ctx->afu->adapter);
 252                 cxl_ctx_put();
 253                 goto out;
 254         }
 255
 256         ctx->status = STARTED;
 257 out:
 258         mutex_unlock(&ctx->status_mutex);
 259         return rc;
 260 }
 261 EXPORT_SYMBOL_GPL(cxl_start_context);
 262
 263 int cxl_process_element(struct cxl_context *ctx)
 264 {
 265         return ctx->external_pe;
 266 }
 267 EXPORT_SYMBOL_GPL(cxl_process_element);
 268
 269 /* Stop a context.  Returns 0 on success, otherwise -Errno */
 270 int cxl_stop_context(struct cxl_context *ctx)
 271 {
 272         return __detach_context(ctx);
 273 }
 274 EXPORT_SYMBOL_GPL(cxl_stop_context);
 275
 276 void cxl_set_master(struct cxl_context *ctx)
 277 {
 278         ctx->master = true;
 279 }
 280 EXPORT_SYMBOL_GPL(cxl_set_master);
 281
 282 int cxl_set_translation_mode(struct cxl_context *ctx, bool real_mode)
 283 {
 284         if (ctx->status == STARTED) {
 285                 /*
 286                  * We could potentially update the PE and issue an update LLCMD
 287                  * to support this, but it doesn't seem to have a good use case
 288                  * since it's trivial to just create a second kernel context
 289                  * with different translation modes, so until someone convinces
 290                  * me otherwise:
 291                  */
 292                 return -EBUSY;
 293         }
 294
 295         ctx->real_mode = real_mode;
 296         return 0;
 297 }
 298 EXPORT_SYMBOL_GPL(cxl_set_translation_mode);
 299
 300 /* wrappers around afu_* file ops which are EXPORTED */
 301 int cxl_fd_open(struct inode *inode, struct file *file)
 302 {
 303         return afu_open(inode, file);
 304 }
 305 EXPORT_SYMBOL_GPL(cxl_fd_open);
 306 int cxl_fd_release(struct inode *inode, struct file *file)
 307 {
 308         return afu_release(inode, file);
 309 }
 310 EXPORT_SYMBOL_GPL(cxl_fd_release);
 311 long cxl_fd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 312 {
 313         return afu_ioctl(file, cmd, arg);
 314 }
 315 EXPORT_SYMBOL_GPL(cxl_fd_ioctl);
 316 int cxl_fd_mmap(struct file *file, struct vm_area_struct *vm)
 317 {
 318         return afu_mmap(file, vm);
 319 }
 320 EXPORT_SYMBOL_GPL(cxl_fd_mmap);
 321 unsigned int cxl_fd_poll(struct file *file, struct poll_table_struct *poll)
 322 {
 323         return afu_poll(file, poll);
 324 }
 325 EXPORT_SYMBOL_GPL(cxl_fd_poll);
 326 ssize_t cxl_fd_read(struct file *file, char __user *buf, size_t count,
 327                         loff_t *off)
 328 {
 329         return afu_read(file, buf, count, off);
 330 }
 331 EXPORT_SYMBOL_GPL(cxl_fd_read);
 332
 333 #define PATCH_FOPS(NAME) if (!fops->NAME) fops->NAME = afu_fops.NAME
 334
 335 /* Get a struct file and fd for a context and attach the ops */
 336 struct file *cxl_get_fd(struct cxl_context *ctx, struct file_operations *fops,
 337                         int *fd)
 338 {
 339         struct file *file;
 340         int rc, flags, fdtmp;
 341
 342         flags = O_RDWR | O_CLOEXEC;
 343
 344         /* This code is similar to anon_inode_getfd() */
 345         rc = get_unused_fd_flags(flags);
 346         if (rc < 0)
 347                 return ERR_PTR(rc);
 348         fdtmp = rc;
 349
 350         /*
 351          * Patch the file ops.  Needs to be careful that this is rentrant safe.
 352          */
 353         if (fops) {
 354                 PATCH_FOPS(open);
 355                 PATCH_FOPS(poll);
 356                 PATCH_FOPS(read);
 357                 PATCH_FOPS(release);
 358                 PATCH_FOPS(unlocked_ioctl);
 359                 PATCH_FOPS(compat_ioctl);
 360                 PATCH_FOPS(mmap);
 361         } else /* use default ops */
 362                 fops = (struct file_operations *)&afu_fops;
 363
 364         file = anon_inode_getfile("cxl", fops, ctx, flags);
 365         if (IS_ERR(file))
 366                 goto err_fd;
 367
 368         file->f_mapping = ctx->mapping;
 369
 370         *fd = fdtmp;
 371         return file;
 372
 373 err_fd:
 374         put_unused_fd(fdtmp);
 375         return NULL;
 376 }
 377 EXPORT_SYMBOL_GPL(cxl_get_fd);
 378
 379 struct cxl_context *cxl_fops_get_context(struct file *file)
 380 {
 381         return file->private_data;
 382 }
 383 EXPORT_SYMBOL_GPL(cxl_fops_get_context);
 384
 385 void cxl_set_driver_ops(struct cxl_context *ctx,
 386                         struct cxl_afu_driver_ops *ops)
 387 {
 388         WARN_ON(!ops->fetch_event || !ops->event_delivered);
 389         atomic_set(&ctx->afu_driver_events, 0);
 390         ctx->afu_driver_ops = ops;
 391 }
 392 EXPORT_SYMBOL_GPL(cxl_set_driver_ops);
 393
 394 void cxl_context_events_pending(struct cxl_context *ctx,
 395                                 unsigned int new_events)
 396 {
 397         atomic_add(new_events, &ctx->afu_driver_events);
 398         wake_up_all(&ctx->wq);
 399 }
 400 EXPORT_SYMBOL_GPL(cxl_context_events_pending);
 401
 402 int cxl_start_work(struct cxl_context *ctx,
 403                    struct cxl_ioctl_start_work *work)
 404 {
 405         int rc;
 406
 407         /* code taken from afu_ioctl_start_work */
 408         if (!(work->flags & CXL_START_WORK_NUM_IRQS))
 409                 work->num_interrupts = ctx->afu->pp_irqs;
 410         else if ((work->num_interrupts < ctx->afu->pp_irqs) ||
 411                  (work->num_interrupts > ctx->afu->irqs_max)) {
 412                 return -EINVAL;
 413         }
 414
 415         rc = afu_register_irqs(ctx, work->num_interrupts);
 416         if (rc)
 417                 return rc;
 418
 419         rc = cxl_start_context(ctx, work->work_element_descriptor, current);
 420         if (rc < 0) {
 421                 afu_release_irqs(ctx, ctx);
 422                 return rc;
 423         }
 424
 425         return 0;
 426 }
 427 EXPORT_SYMBOL_GPL(cxl_start_work);
 428
 429 void __iomem *cxl_psa_map(struct cxl_context *ctx)
 430 {
 431         if (ctx->status != STARTED)
 432                 return NULL;
 433
 434         pr_devel("%s: psn_phys%llx size:%llx\n",
 435                 __func__, ctx->psn_phys, ctx->psn_size);
 436         return ioremap(ctx->psn_phys, ctx->psn_size);
 437 }
 438 EXPORT_SYMBOL_GPL(cxl_psa_map);
 439
 440 void cxl_psa_unmap(void __iomem *addr)
 441 {
 442         iounmap(addr);
 443 }
 444 EXPORT_SYMBOL_GPL(cxl_psa_unmap);
 445
 446 int cxl_afu_reset(struct cxl_context *ctx)
 447 {
 448         struct cxl_afu *afu = ctx->afu;
 449         int rc;
 450
 451         rc = cxl_ops->afu_reset(afu);
 452         if (rc)
 453                 return rc;
 454
 455         return cxl_ops->afu_check_and_enable(afu);
 456 }
 457 EXPORT_SYMBOL_GPL(cxl_afu_reset);
 458
 459 void cxl_perst_reloads_same_image(struct cxl_afu *afu,
 460                                   bool perst_reloads_same_image)
 461 {
 462         afu->adapter->perst_same_image = perst_reloads_same_image;
 463 }
 464 EXPORT_SYMBOL_GPL(cxl_perst_reloads_same_image);
 465
 466 ssize_t cxl_read_adapter_vpd(struct pci_dev *dev, void *buf, size_t count)
 467 {
 468         struct cxl_afu *afu = cxl_pci_to_afu(dev);
 469         if (IS_ERR(afu))
 470                 return -ENODEV;
 471
 472         return cxl_ops->read_adapter_vpd(afu->adapter, buf, count);
 473 }
 474 EXPORT_SYMBOL_GPL(cxl_read_adapter_vpd);
 475
 476 int cxl_set_max_irqs_per_process(struct pci_dev *dev, int irqs)
 477 {
 478         struct cxl_afu *afu = cxl_pci_to_afu(dev);
 479         if (IS_ERR(afu))
 480                 return -ENODEV;
 481
 482         if (irqs > afu->adapter->user_irqs)
 483                 return -EINVAL;
 484
 485         /* Limit user_irqs to prevent the user increasing this via sysfs */
 486         afu->adapter->user_irqs = irqs;
 487         afu->irqs_max = irqs;
 488
 489         return 0;
 490 }
 491 EXPORT_SYMBOL_GPL(cxl_set_max_irqs_per_process);
 492
 493 int cxl_get_max_irqs_per_process(struct pci_dev *dev)
 494 {
 495         struct cxl_afu *afu = cxl_pci_to_afu(dev);
 496         if (IS_ERR(afu))
 497                 return -ENODEV;
 498
 499         return afu->irqs_max;
 500 }
 501 EXPORT_SYMBOL_GPL(cxl_get_max_irqs_per_process);
 502
 503 /*
 504  * This is a special interrupt allocation routine called from the PHB's MSI
 505  * setup function. When capi interrupts are allocated in this manner they must
 506  * still be associated with a running context, but since the MSI APIs have no
 507  * way to specify this we use the default context associated with the device.
 508  *
 509  * The Mellanox CX4 has a hardware limitation that restricts the maximum AFU
 510  * interrupt number, so in order to overcome this their driver informs us of
 511  * the restriction by setting the maximum interrupts per context, and we
 512  * allocate additional contexts as necessary so that we can keep the AFU
 513  * interrupt number within the supported range.
 514  */
 515 int _cxl_cx4_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
 516 {
 517         struct cxl_context *ctx, *new_ctx, *default_ctx;
 518         int remaining;
 519         int rc;
 520
 521         ctx = default_ctx = cxl_get_context(pdev);
 522         if (WARN_ON(!default_ctx))
 523                 return -ENODEV;
 524
 525         remaining = nvec;
 526         while (remaining > 0) {
 527                 rc = cxl_allocate_afu_irqs(ctx, min(remaining, ctx->afu->irqs_max));
 528                 if (rc) {
 529                         pr_warn("%s: Failed to find enough free MSIs\n", pci_name(pdev));
 530                         return rc;
 531                 }
 532                 remaining -= ctx->afu->irqs_max;
 533
 534                 if (ctx != default_ctx && default_ctx->status == STARTED) {
 535                         WARN_ON(cxl_start_context(ctx,
 536                                 be64_to_cpu(default_ctx->elem->common.wed),
 537                                 NULL));
 538                 }
 539
 540                 if (remaining > 0) {
 541                         new_ctx = cxl_dev_context_init(pdev);
 542                         if (!new_ctx) {
 543                                 pr_warn("%s: Failed to allocate enough contexts for MSIs\n", pci_name(pdev));
 544                                 return -ENOSPC;
 545                         }
 546                         list_add(&new_ctx->extra_irq_contexts, &ctx->extra_irq_contexts);
 547                         ctx = new_ctx;
 548                 }
 549         }
 550
 551         return 0;
 552 }
 553 /* Exported via cxl_base */
 554
 555 void _cxl_cx4_teardown_msi_irqs(struct pci_dev *pdev)
 556 {
 557         struct cxl_context *ctx, *pos, *tmp;
 558
 559         ctx = cxl_get_context(pdev);
 560         if (WARN_ON(!ctx))
 561                 return;
 562
 563         cxl_free_afu_irqs(ctx);
 564         list_for_each_entry_safe(pos, tmp, &ctx->extra_irq_contexts, extra_irq_contexts) {
 565                 cxl_stop_context(pos);
 566                 cxl_free_afu_irqs(pos);
 567                 list_del(&pos->extra_irq_contexts);
 568                 cxl_release_context(pos);
 569         }
 570 }
 571 /* Exported via cxl_base */