drivers/s390/cio/vfio_ccw_drv.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * VFIO based Physical Subchannel device driver
   4  *
   5  * Copyright IBM Corp. 2017
   6  *
   7  * Author(s): Dong Jia Shi <bjsdjshi@linux.vnet.ibm.com>
   8  *            Xiao Feng Ren <renxiaof@linux.vnet.ibm.com>
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/device.h>
  14 #include <linux/slab.h>
  15 #include <linux/uuid.h>
  16 #include <linux/mdev.h>
  17
  18 #include <asm/isc.h>
  19
  20 #include "ioasm.h"
  21 #include "css.h"
  22 #include "vfio_ccw_private.h"
  23
  24 struct workqueue_struct *vfio_ccw_work_q;
  25 static struct kmem_cache *vfio_ccw_io_region;
  26
  27 /*
  28  * Helpers
  29  */
  30 int vfio_ccw_sch_quiesce(struct subchannel *sch)
  31 {
  32         struct vfio_ccw_private *private = dev_get_drvdata(&sch->dev);
  33         DECLARE_COMPLETION_ONSTACK(completion);
  34         int iretry, ret = 0;
  35
  36         spin_lock_irq(sch->lock);
  37         if (!sch->schib.pmcw.ena)
  38                 goto out_unlock;
  39         ret = cio_disable_subchannel(sch);
  40         if (ret != -EBUSY)
  41                 goto out_unlock;
  42
  43         iretry = 255;
  44         do {
  45
  46                 ret = cio_cancel_halt_clear(sch, &iretry);
  47
  48                 if (ret == -EIO) {
  49                         pr_err("vfio_ccw: could not quiesce subchannel 0.%x.%04x!\n",
  50                                sch->schid.ssid, sch->schid.sch_no);
  51                         break;
  52                 }
  53
  54                 /*
  55                  * Flush all I/O and wait for
  56                  * cancel/halt/clear completion.
  57                  */
  58                 private->completion = &completion;
  59                 spin_unlock_irq(sch->lock);
  60
  61                 if (ret == -EBUSY)
  62                         wait_for_completion_timeout(&completion, 3*HZ);
  63
  64                 private->completion = NULL;
  65                 flush_workqueue(vfio_ccw_work_q);
  66                 spin_lock_irq(sch->lock);
  67                 ret = cio_disable_subchannel(sch);
  68         } while (ret == -EBUSY);
  69 out_unlock:
  70         private->state = VFIO_CCW_STATE_NOT_OPER;
  71         spin_unlock_irq(sch->lock);
  72         return ret;
  73 }
  74
  75 static void vfio_ccw_sch_io_todo(struct work_struct *work)
  76 {
  77         struct vfio_ccw_private *private;
  78         struct irb *irb;
  79         bool is_final;
  80
  81         private = container_of(work, struct vfio_ccw_private, io_work);
  82         irb = &private->irb;
  83
  84         is_final = !(scsw_actl(&irb->scsw) &
  85                      (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT));
  86         if (scsw_is_solicited(&irb->scsw)) {
  87                 cp_update_scsw(&private->cp, &irb->scsw);
  88                 if (is_final)
  89                         cp_free(&private->cp);
  90         }
  91         memcpy(private->io_region->irb_area, irb, sizeof(*irb));
  92
  93         if (private->io_trigger)
  94                 eventfd_signal(private->io_trigger, 1);
  95
  96         if (private->mdev && is_final)
  97                 private->state = VFIO_CCW_STATE_IDLE;
  98 }
  99
 100 /*
 101  * Css driver callbacks
 102  */
 103 static void vfio_ccw_sch_irq(struct subchannel *sch)
 104 {
 105         struct vfio_ccw_private *private = dev_get_drvdata(&sch->dev);
 106
 107         inc_irq_stat(IRQIO_CIO);
 108         vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_INTERRUPT);
 109 }
 110
 111 static int vfio_ccw_sch_probe(struct subchannel *sch)
 112 {
 113         struct pmcw *pmcw = &sch->schib.pmcw;
 114         struct vfio_ccw_private *private;
 115         int ret;
 116
 117         if (pmcw->qf) {
 118                 dev_warn(&sch->dev, "vfio: ccw: does not support QDIO: %s\n",
 119                          dev_name(&sch->dev));
 120                 return -ENODEV;
 121         }
 122
 123         private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA);
 124         if (!private)
 125                 return -ENOMEM;
 126
 127         private->io_region = kmem_cache_zalloc(vfio_ccw_io_region,
 128                                                GFP_KERNEL | GFP_DMA);
 129         if (!private->io_region) {
 130                 kfree(private);
 131                 return -ENOMEM;
 132         }
 133
 134         private->sch = sch;
 135         dev_set_drvdata(&sch->dev, private);
 136
 137         spin_lock_irq(sch->lock);
 138         private->state = VFIO_CCW_STATE_NOT_OPER;
 139         sch->isc = VFIO_CCW_ISC;
 140         ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch);
 141         spin_unlock_irq(sch->lock);
 142         if (ret)
 143                 goto out_free;
 144
 145         INIT_WORK(&private->io_work, vfio_ccw_sch_io_todo);
 146         atomic_set(&private->avail, 1);
 147         private->state = VFIO_CCW_STATE_STANDBY;
 148
 149         ret = vfio_ccw_mdev_reg(sch);
 150         if (ret)
 151                 goto out_disable;
 152
 153         return 0;
 154
 155 out_disable:
 156         cio_disable_subchannel(sch);
 157 out_free:
 158         dev_set_drvdata(&sch->dev, NULL);
 159         kmem_cache_free(vfio_ccw_io_region, private->io_region);
 160         kfree(private);
 161         return ret;
 162 }
 163
 164 static int vfio_ccw_sch_remove(struct subchannel *sch)
 165 {
 166         struct vfio_ccw_private *private = dev_get_drvdata(&sch->dev);
 167
 168         vfio_ccw_sch_quiesce(sch);
 169
 170         vfio_ccw_mdev_unreg(sch);
 171
 172         dev_set_drvdata(&sch->dev, NULL);
 173
 174         kmem_cache_free(vfio_ccw_io_region, private->io_region);
 175         kfree(private);
 176
 177         return 0;
 178 }
 179
 180 static void vfio_ccw_sch_shutdown(struct subchannel *sch)
 181 {
 182         vfio_ccw_sch_quiesce(sch);
 183 }
 184
 185 /**
 186  * vfio_ccw_sch_event - process subchannel event
 187  * @sch: subchannel
 188  * @process: non-zero if function is called in process context
 189  *
 190  * An unspecified event occurred for this subchannel. Adjust data according
 191  * to the current operational state of the subchannel. Return zero when the
 192  * event has been handled sufficiently or -EAGAIN when this function should
 193  * be called again in process context.
 194  */
 195 static int vfio_ccw_sch_event(struct subchannel *sch, int process)
 196 {
 197         struct vfio_ccw_private *private = dev_get_drvdata(&sch->dev);
 198         unsigned long flags;
 199         int rc = -EAGAIN;
 200
 201         spin_lock_irqsave(sch->lock, flags);
 202         if (!device_is_registered(&sch->dev))
 203                 goto out_unlock;
 204
 205         if (work_pending(&sch->todo_work))
 206                 goto out_unlock;
 207
 208         if (cio_update_schib(sch)) {
 209                 vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_NOT_OPER);
 210                 rc = 0;
 211                 goto out_unlock;
 212         }
 213
 214         private = dev_get_drvdata(&sch->dev);
 215         if (private->state == VFIO_CCW_STATE_NOT_OPER) {
 216                 private->state = private->mdev ? VFIO_CCW_STATE_IDLE :
 217                                  VFIO_CCW_STATE_STANDBY;
 218         }
 219         rc = 0;
 220
 221 out_unlock:
 222         spin_unlock_irqrestore(sch->lock, flags);
 223
 224         return rc;
 225 }
 226
 227 static struct css_device_id vfio_ccw_sch_ids[] = {
 228         { .match_flags = 0x1, .type = SUBCHANNEL_TYPE_IO, },
 229         { /* end of list */ },
 230 };
 231 MODULE_DEVICE_TABLE(css, vfio_ccw_sch_ids);
 232
 233 static struct css_driver vfio_ccw_sch_driver = {
 234         .drv = {
 235                 .name = "vfio_ccw",
 236                 .owner = THIS_MODULE,
 237         },
 238         .subchannel_type = vfio_ccw_sch_ids,
 239         .irq = vfio_ccw_sch_irq,
 240         .probe = vfio_ccw_sch_probe,
 241         .remove = vfio_ccw_sch_remove,
 242         .shutdown = vfio_ccw_sch_shutdown,
 243         .sch_event = vfio_ccw_sch_event,
 244 };
 245
 246 static int __init vfio_ccw_sch_init(void)
 247 {
 248         int ret;
 249
 250         vfio_ccw_work_q = create_singlethread_workqueue("vfio-ccw");
 251         if (!vfio_ccw_work_q)
 252                 return -ENOMEM;
 253
 254         vfio_ccw_io_region = kmem_cache_create_usercopy("vfio_ccw_io_region",
 255                                         sizeof(struct ccw_io_region), 0,
 256                                         SLAB_ACCOUNT, 0,
 257                                         sizeof(struct ccw_io_region), NULL);
 258         if (!vfio_ccw_io_region) {
 259                 destroy_workqueue(vfio_ccw_work_q);
 260                 return -ENOMEM;
 261         }
 262
 263         isc_register(VFIO_CCW_ISC);
 264         ret = css_driver_register(&vfio_ccw_sch_driver);
 265         if (ret) {
 266                 isc_unregister(VFIO_CCW_ISC);
 267                 kmem_cache_destroy(vfio_ccw_io_region);
 268                 destroy_workqueue(vfio_ccw_work_q);
 269         }
 270
 271         return ret;
 272 }
 273
 274 static void __exit vfio_ccw_sch_exit(void)
 275 {
 276         css_driver_unregister(&vfio_ccw_sch_driver);
 277         isc_unregister(VFIO_CCW_ISC);
 278         kmem_cache_destroy(vfio_ccw_io_region);
 279         destroy_workqueue(vfio_ccw_work_q);
 280 }
 281 module_init(vfio_ccw_sch_init);
 282 module_exit(vfio_ccw_sch_exit);
 283
 284 MODULE_LICENSE("GPL v2");