[linux-block.git] / drivers / s390 / cio / vfio_ccw_fsm.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Finite state machine for vfio-ccw device handling
 *
 * Copyright IBM Corp. 2017
 *
 * Author(s): Dong Jia Shi <bjsdjshi@linux.vnet.ibm.com>
 */

#include <linux/vfio.h>
#include <linux/mdev.h>

#include "ioasm.h"
#include "vfio_ccw_private.h"

#define CREATE_TRACE_POINTS
#include "vfio_ccw_trace.h"

static int fsm_io_helper(struct vfio_ccw_private *private)
{
	struct subchannel *sch;
	union orb *orb;
	int ccode;
	__u8 lpm;
	unsigned long flags;
	int ret;

	sch = private->sch;

	spin_lock_irqsave(sch->lock, flags);
	private->state = VFIO_CCW_STATE_BUSY;

	orb = cp_get_orb(&private->cp, (u32)(addr_t)sch, sch->lpm);

	/* Issue "Start Subchannel" */
	ccode = ssch(sch->schid, orb);

	switch (ccode) {
	case 0:
		/*
		 * Initialize device status information
		 */
		sch->schib.scsw.cmd.actl |= SCSW_ACTL_START_PEND;
		ret = 0;
		break;
	case 1:		/* Status pending */
	case 2:		/* Busy */
		ret = -EBUSY;
		break;
	case 3:		/* Device/path not operational */
	{
		lpm = orb->cmd.lpm;
		if (lpm != 0)
			sch->lpm &= ~lpm;
		else
			sch->lpm = 0;

		if (cio_update_schib(sch))
			ret = -ENODEV;
		else
			ret = sch->lpm ? -EACCES : -ENODEV;
		break;
	}
	default:
		ret = ccode;
	}
	spin_unlock_irqrestore(sch->lock, flags);
	return ret;
}

static void fsm_notoper(struct vfio_ccw_private *private,
			enum vfio_ccw_event event)
{
	struct subchannel *sch = private->sch;

	/*
	 * TODO:
	 * Probably we should send the machine check to the guest.
	 */
	css_sched_sch_todo(sch, SCH_TODO_UNREG);
	private->state = VFIO_CCW_STATE_NOT_OPER;
}

/*
 * No operation action.
 */
static void fsm_nop(struct vfio_ccw_private *private,
		    enum vfio_ccw_event event)
{
}

static void fsm_io_error(struct vfio_ccw_private *private,
			 enum vfio_ccw_event event)
{
	pr_err("vfio-ccw: FSM: I/O request from state:%d\n", private->state);
	private->io_region.ret_code = -EIO;
}

static void fsm_io_busy(struct vfio_ccw_private *private,
			enum vfio_ccw_event event)
{
	private->io_region.ret_code = -EBUSY;
}

static void fsm_disabled_irq(struct vfio_ccw_private *private,
			     enum vfio_ccw_event event)
{
	struct subchannel *sch = private->sch;

	/*
	 * An interrupt in a disabled state means a previous disable was not
	 * successful - should not happen, but we try to disable again.
	 */
	cio_disable_subchannel(sch);
}
inline struct subchannel_id get_schid(struct vfio_ccw_private *p)
{
	return p->sch->schid;
}

/*
 * Deal with the ccw command request from the userspace.
 */
static void fsm_io_request(struct vfio_ccw_private *private,
			   enum vfio_ccw_event event)
{
	union orb *orb;
	union scsw *scsw = &private->scsw;
	struct ccw_io_region *io_region = &private->io_region;
	struct mdev_device *mdev = private->mdev;
	char *errstr = "request";

	private->state = VFIO_CCW_STATE_BOXED;

	memcpy(scsw, io_region->scsw_area, sizeof(*scsw));

	if (scsw->cmd.fctl & SCSW_FCTL_START_FUNC) {
		orb = (union orb *)io_region->orb_area;

		/* Don't try to build a cp if transport mode is specified. */
		if (orb->tm.b) {
			io_region->ret_code = -EOPNOTSUPP;
			errstr = "transport mode";
			goto err_out;
		}
		io_region->ret_code = cp_init(&private->cp, mdev_dev(mdev),
					      orb);
		if (io_region->ret_code) {
			errstr = "cp init";
			goto err_out;
		}

		io_region->ret_code = cp_prefetch(&private->cp);
		if (io_region->ret_code) {
			errstr = "cp prefetch";
			cp_free(&private->cp);
			goto err_out;
		}

		/* Start channel program and wait for I/O interrupt. */
		io_region->ret_code = fsm_io_helper(private);
		if (io_region->ret_code) {
			errstr = "cp fsm_io_helper";
			cp_free(&private->cp);
			goto err_out;
		}
		return;
	} else if (scsw->cmd.fctl & SCSW_FCTL_HALT_FUNC) {
		/* XXX: Handle halt. */
		io_region->ret_code = -EOPNOTSUPP;
		goto err_out;
	} else if (scsw->cmd.fctl & SCSW_FCTL_CLEAR_FUNC) {
		/* XXX: Handle clear. */
		io_region->ret_code = -EOPNOTSUPP;
		goto err_out;
	}

err_out:
	private->state = VFIO_CCW_STATE_IDLE;
	trace_vfio_ccw_io_fctl(scsw->cmd.fctl, get_schid(private),
			       io_region->ret_code, errstr);
}

/*
 * Got an interrupt for a normal io (state busy).
 */
static void fsm_irq(struct vfio_ccw_private *private,
		    enum vfio_ccw_event event)
{
	struct irb *irb = this_cpu_ptr(&cio_irb);

	memcpy(&private->irb, irb, sizeof(*irb));

	queue_work(vfio_ccw_work_q, &private->io_work);

	if (private->completion)
		complete(private->completion);
}

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