drivers/s390/cio/vfio_ccw_fsm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Finite state machine for vfio-ccw device handling
   4  *
   5  * Copyright IBM Corp. 2017
   6  *
   7  * Author(s): Dong Jia Shi <bjsdjshi@linux.vnet.ibm.com>
   8  */
   9
  10 #include <linux/vfio.h>
  11 #include <linux/mdev.h>
  12
  13 #include "ioasm.h"
  14 #include "vfio_ccw_private.h"
  15
  16 static int fsm_io_helper(struct vfio_ccw_private *private)
  17 {
  18         struct subchannel *sch;
  19         union orb *orb;
  20         int ccode;
  21         __u8 lpm;
  22         unsigned long flags;
  23
  24         sch = private->sch;
  25
  26         spin_lock_irqsave(sch->lock, flags);
  27         private->state = VFIO_CCW_STATE_BUSY;
  28         spin_unlock_irqrestore(sch->lock, flags);
  29
  30         orb = cp_get_orb(&private->cp, (u32)(addr_t)sch, sch->lpm);
  31
  32         /* Issue "Start Subchannel" */
  33         ccode = ssch(sch->schid, orb);
  34
  35         switch (ccode) {
  36         case 0:
  37                 /*
  38                  * Initialize device status information
  39                  */
  40                 sch->schib.scsw.cmd.actl |= SCSW_ACTL_START_PEND;
  41                 return 0;
  42         case 1:         /* Status pending */
  43         case 2:         /* Busy */
  44                 return -EBUSY;
  45         case 3:         /* Device/path not operational */
  46         {
  47                 lpm = orb->cmd.lpm;
  48                 if (lpm != 0)
  49                         sch->lpm &= ~lpm;
  50                 else
  51                         sch->lpm = 0;
  52
  53                 if (cio_update_schib(sch))
  54                         return -ENODEV;
  55
  56                 return sch->lpm ? -EACCES : -ENODEV;
  57         }
  58         default:
  59                 return ccode;
  60         }
  61 }
  62
  63 static void fsm_notoper(struct vfio_ccw_private *private,
  64                         enum vfio_ccw_event event)
  65 {
  66         struct subchannel *sch = private->sch;
  67
  68         /*
  69          * TODO:
  70          * Probably we should send the machine check to the guest.
  71          */
  72         css_sched_sch_todo(sch, SCH_TODO_UNREG);
  73         private->state = VFIO_CCW_STATE_NOT_OPER;
  74 }
  75
  76 /*
  77  * No operation action.
  78  */
  79 static void fsm_nop(struct vfio_ccw_private *private,
  80                     enum vfio_ccw_event event)
  81 {
  82 }
  83
  84 static void fsm_io_error(struct vfio_ccw_private *private,
  85                          enum vfio_ccw_event event)
  86 {
  87         pr_err("vfio-ccw: FSM: I/O request from state:%d\n", private->state);
  88         private->io_region.ret_code = -EIO;
  89 }
  90
  91 static void fsm_io_busy(struct vfio_ccw_private *private,
  92                         enum vfio_ccw_event event)
  93 {
  94         private->io_region.ret_code = -EBUSY;
  95 }
  96
  97 static void fsm_disabled_irq(struct vfio_ccw_private *private,
  98                              enum vfio_ccw_event event)
  99 {
 100         struct subchannel *sch = private->sch;
 101
 102         /*
 103          * An interrupt in a disabled state means a previous disable was not
 104          * successful - should not happen, but we try to disable again.
 105          */
 106         cio_disable_subchannel(sch);
 107 }
 108
 109 /*
 110  * Deal with the ccw command request from the userspace.
 111  */
 112 static void fsm_io_request(struct vfio_ccw_private *private,
 113                            enum vfio_ccw_event event)
 114 {
 115         union orb *orb;
 116         union scsw *scsw = &private->scsw;
 117         struct ccw_io_region *io_region = &private->io_region;
 118         struct mdev_device *mdev = private->mdev;
 119
 120         private->state = VFIO_CCW_STATE_BOXED;
 121
 122         memcpy(scsw, io_region->scsw_area, sizeof(*scsw));
 123
 124         if (scsw->cmd.fctl & SCSW_FCTL_START_FUNC) {
 125                 orb = (union orb *)io_region->orb_area;
 126
 127                 /* Don't try to build a cp if transport mode is specified. */
 128                 if (orb->tm.b) {
 129                         io_region->ret_code = -EOPNOTSUPP;
 130                         goto err_out;
 131                 }
 132                 io_region->ret_code = cp_init(&private->cp, mdev_dev(mdev),
 133                                               orb);
 134                 if (io_region->ret_code)
 135                         goto err_out;
 136
 137                 io_region->ret_code = cp_prefetch(&private->cp);
 138                 if (io_region->ret_code) {
 139                         cp_free(&private->cp);
 140                         goto err_out;
 141                 }
 142
 143                 /* Start channel program and wait for I/O interrupt. */
 144                 io_region->ret_code = fsm_io_helper(private);
 145                 if (io_region->ret_code) {
 146                         cp_free(&private->cp);
 147                         goto err_out;
 148                 }
 149                 return;
 150         } else if (scsw->cmd.fctl & SCSW_FCTL_HALT_FUNC) {
 151                 /* XXX: Handle halt. */
 152                 io_region->ret_code = -EOPNOTSUPP;
 153                 goto err_out;
 154         } else if (scsw->cmd.fctl & SCSW_FCTL_CLEAR_FUNC) {
 155                 /* XXX: Handle clear. */
 156                 io_region->ret_code = -EOPNOTSUPP;
 157                 goto err_out;
 158         }
 159
 160 err_out:
 161         private->state = VFIO_CCW_STATE_IDLE;
 162 }
 163
 164 /*
 165  * Got an interrupt for a normal io (state busy).
 166  */
 167 static void fsm_irq(struct vfio_ccw_private *private,
 168                     enum vfio_ccw_event event)
 169 {
 170         struct irb *irb = this_cpu_ptr(&cio_irb);
 171
 172         memcpy(&private->irb, irb, sizeof(*irb));
 173
 174         queue_work(vfio_ccw_work_q, &private->io_work);
 175
 176         if (private->completion)
 177                 complete(private->completion);
 178 }
 179
 180 /*
 181  * Device statemachine
 182  */
 183 fsm_func_t *vfio_ccw_jumptable[NR_VFIO_CCW_STATES][NR_VFIO_CCW_EVENTS] = {
 184         [VFIO_CCW_STATE_NOT_OPER] = {
 185                 [VFIO_CCW_EVENT_NOT_OPER]       = fsm_nop,
 186                 [VFIO_CCW_EVENT_IO_REQ]         = fsm_io_error,
 187                 [VFIO_CCW_EVENT_INTERRUPT]      = fsm_disabled_irq,
 188         },
 189         [VFIO_CCW_STATE_STANDBY] = {
 190                 [VFIO_CCW_EVENT_NOT_OPER]       = fsm_notoper,
 191                 [VFIO_CCW_EVENT_IO_REQ]         = fsm_io_error,
 192                 [VFIO_CCW_EVENT_INTERRUPT]      = fsm_irq,
 193         },
 194         [VFIO_CCW_STATE_IDLE] = {
 195                 [VFIO_CCW_EVENT_NOT_OPER]       = fsm_notoper,
 196                 [VFIO_CCW_EVENT_IO_REQ]         = fsm_io_request,
 197                 [VFIO_CCW_EVENT_INTERRUPT]      = fsm_irq,
 198         },
 199         [VFIO_CCW_STATE_BOXED] = {
 200                 [VFIO_CCW_EVENT_NOT_OPER]       = fsm_notoper,
 201                 [VFIO_CCW_EVENT_IO_REQ]         = fsm_io_busy,
 202                 [VFIO_CCW_EVENT_INTERRUPT]      = fsm_irq,
 203         },
 204         [VFIO_CCW_STATE_BUSY] = {
 205                 [VFIO_CCW_EVENT_NOT_OPER]       = fsm_notoper,
 206                 [VFIO_CCW_EVENT_IO_REQ]         = fsm_io_busy,
 207                 [VFIO_CCW_EVENT_INTERRUPT]      = fsm_irq,
 208         },
 209 };