[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / s390 / cio / device_status.c

/*
 *    Copyright IBM Corp. 2002
 *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
 *		 Martin Schwidefsky (schwidefsky@de.ibm.com)
 *
 * Status accumulation and basic sense functions.
 */

#include <linux/module.h>
#include <linux/init.h>

#include <asm/ccwdev.h>
#include <asm/cio.h>

#include "cio.h"
#include "cio_debug.h"
#include "css.h"
#include "device.h"
#include "ioasm.h"
#include "io_sch.h"

/*
 * Check for any kind of channel or interface control check but don't
 * issue the message for the console device
 */
static void
ccw_device_msg_control_check(struct ccw_device *cdev, struct irb *irb)
{
	char dbf_text[15];

	if (!scsw_is_valid_cstat(&irb->scsw) ||
	    !(scsw_cstat(&irb->scsw) & (SCHN_STAT_CHN_DATA_CHK |
	      SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK)))
		return;
	CIO_MSG_EVENT(0, "Channel-Check or Interface-Control-Check "
		      "received"
		      " ... device %04x on subchannel 0.%x.%04x, dev_stat "
		      ": %02X sch_stat : %02X\n",
		      cdev->private->dev_id.devno, cdev->private->schid.ssid,
		      cdev->private->schid.sch_no,
		      scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw));
	sprintf(dbf_text, "chk%x", cdev->private->schid.sch_no);
	CIO_TRACE_EVENT(0, dbf_text);
	CIO_HEX_EVENT(0, irb, sizeof(struct irb));
}

/*
 * Some paths became not operational (pno bit in scsw is set).
 */
static void
ccw_device_path_notoper(struct ccw_device *cdev)
{
	struct subchannel *sch;

	sch = to_subchannel(cdev->dev.parent);
	if (cio_update_schib(sch))
		goto doverify;

	CIO_MSG_EVENT(0, "%s(0.%x.%04x) - path(s) %02x are "
		      "not operational \n", __func__,
		      sch->schid.ssid, sch->schid.sch_no,
		      sch->schib.pmcw.pnom);

	sch->lpm &= ~sch->schib.pmcw.pnom;
doverify:
	cdev->private->flags.doverify = 1;
}

/*
 * Copy valid bits from the extended control word to device irb.
 */
static void
ccw_device_accumulate_ecw(struct ccw_device *cdev, struct irb *irb)
{
	/*
	 * Copy extended control bit if it is valid... yes there
	 * are condition that have to be met for the extended control
	 * bit to have meaning. Sick.
	 */
	cdev->private->irb.scsw.cmd.ectl = 0;
	if ((irb->scsw.cmd.stctl & SCSW_STCTL_ALERT_STATUS) &&
	    !(irb->scsw.cmd.stctl & SCSW_STCTL_INTER_STATUS))
		cdev->private->irb.scsw.cmd.ectl = irb->scsw.cmd.ectl;
	/* Check if extended control word is valid. */
	if (!cdev->private->irb.scsw.cmd.ectl)
		return;
	/* Copy concurrent sense / model dependent information. */
	memcpy (&cdev->private->irb.ecw, irb->ecw, sizeof (irb->ecw));
}

/*
 * Check if extended status word is valid.
 */
static int
ccw_device_accumulate_esw_valid(struct irb *irb)
{
	if (!irb->scsw.cmd.eswf &&
	    (irb->scsw.cmd.stctl == SCSW_STCTL_STATUS_PEND))
		return 0;
	if (irb->scsw.cmd.stctl ==
			(SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND) &&
	    !(irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
		return 0;
	return 1;
}

/*
 * Copy valid bits from the extended status word to device irb.
 */
static void
ccw_device_accumulate_esw(struct ccw_device *cdev, struct irb *irb)
{
	struct irb *cdev_irb;
	struct sublog *cdev_sublog, *sublog;

	if (!ccw_device_accumulate_esw_valid(irb))
		return;

	cdev_irb = &cdev->private->irb;

	/* Copy last path used mask. */
	cdev_irb->esw.esw1.lpum = irb->esw.esw1.lpum;

	/* Copy subchannel logout information if esw is of format 0. */
	if (irb->scsw.cmd.eswf) {
		cdev_sublog = &cdev_irb->esw.esw0.sublog;
		sublog = &irb->esw.esw0.sublog;
		/* Copy extended status flags. */
		cdev_sublog->esf = sublog->esf;
		/*
		 * Copy fields that have a meaning for channel data check
		 * channel control check and interface control check.
		 */
		if (irb->scsw.cmd.cstat & (SCHN_STAT_CHN_DATA_CHK |
				       SCHN_STAT_CHN_CTRL_CHK |
				       SCHN_STAT_INTF_CTRL_CHK)) {
			/* Copy ancillary report bit. */
			cdev_sublog->arep = sublog->arep;
			/* Copy field-validity-flags. */
			cdev_sublog->fvf = sublog->fvf;
			/* Copy storage access code. */
			cdev_sublog->sacc = sublog->sacc;
			/* Copy termination code. */
			cdev_sublog->termc = sublog->termc;
			/* Copy sequence code. */
			cdev_sublog->seqc = sublog->seqc;
		}
		/* Copy device status check. */
		cdev_sublog->devsc = sublog->devsc;
		/* Copy secondary error. */
		cdev_sublog->serr = sublog->serr;
		/* Copy i/o-error alert. */
		cdev_sublog->ioerr = sublog->ioerr;
		/* Copy channel path timeout bit. */
		if (irb->scsw.cmd.cstat & SCHN_STAT_INTF_CTRL_CHK)
			cdev_irb->esw.esw0.erw.cpt = irb->esw.esw0.erw.cpt;
		/* Copy failing storage address validity flag. */
		cdev_irb->esw.esw0.erw.fsavf = irb->esw.esw0.erw.fsavf;
		if (cdev_irb->esw.esw0.erw.fsavf) {
			/* ... and copy the failing storage address. */
			memcpy(cdev_irb->esw.esw0.faddr, irb->esw.esw0.faddr,
			       sizeof (irb->esw.esw0.faddr));
			/* ... and copy the failing storage address format. */
			cdev_irb->esw.esw0.erw.fsaf = irb->esw.esw0.erw.fsaf;
		}
		/* Copy secondary ccw address validity bit. */
		cdev_irb->esw.esw0.erw.scavf = irb->esw.esw0.erw.scavf;
		if (irb->esw.esw0.erw.scavf)
			/* ... and copy the secondary ccw address. */
			cdev_irb->esw.esw0.saddr = irb->esw.esw0.saddr;
		
	}
	/* FIXME: DCTI for format 2? */

	/* Copy authorization bit. */
	cdev_irb->esw.esw0.erw.auth = irb->esw.esw0.erw.auth;
	/* Copy path verification required flag. */
	cdev_irb->esw.esw0.erw.pvrf = irb->esw.esw0.erw.pvrf;
	if (irb->esw.esw0.erw.pvrf)
		cdev->private->flags.doverify = 1;
	/* Copy concurrent sense bit. */
	cdev_irb->esw.esw0.erw.cons = irb->esw.esw0.erw.cons;
	if (irb->esw.esw0.erw.cons)
		cdev_irb->esw.esw0.erw.scnt = irb->esw.esw0.erw.scnt;
}

/*
 * Accumulate status from irb to devstat.
 */
void
ccw_device_accumulate_irb(struct ccw_device *cdev, struct irb *irb)
{
	struct irb *cdev_irb;

	/*
	 * Check if the status pending bit is set in stctl.
	 * If not, the remaining bit have no meaning and we must ignore them.
	 * The esw is not meaningful as well...
	 */
	if (!(scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))
		return;

	/* Check for channel checks and interface control checks. */
	ccw_device_msg_control_check(cdev, irb);

	/* Check for path not operational. */
	if (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw))
		ccw_device_path_notoper(cdev);
	/* No irb accumulation for transport mode irbs. */
	if (scsw_is_tm(&irb->scsw)) {
		memcpy(&cdev->private->irb, irb, sizeof(struct irb));
		return;
	}
	/*
	 * Don't accumulate unsolicited interrupts.
	 */
	if (!scsw_is_solicited(&irb->scsw))
		return;

	cdev_irb = &cdev->private->irb;

	/*
	 * If the clear function had been performed, all formerly pending
	 * status at the subchannel has been cleared and we must not pass
	 * intermediate accumulated status to the device driver.
	 */
	if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
		memset(&cdev->private->irb, 0, sizeof(struct irb));

	/* Copy bits which are valid only for the start function. */
	if (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) {
		/* Copy key. */
		cdev_irb->scsw.cmd.key = irb->scsw.cmd.key;
		/* Copy suspend control bit. */
		cdev_irb->scsw.cmd.sctl = irb->scsw.cmd.sctl;
		/* Accumulate deferred condition code. */
		cdev_irb->scsw.cmd.cc |= irb->scsw.cmd.cc;
		/* Copy ccw format bit. */
		cdev_irb->scsw.cmd.fmt = irb->scsw.cmd.fmt;
		/* Copy prefetch bit. */
		cdev_irb->scsw.cmd.pfch = irb->scsw.cmd.pfch;
		/* Copy initial-status-interruption-control. */
		cdev_irb->scsw.cmd.isic = irb->scsw.cmd.isic;
		/* Copy address limit checking control. */
		cdev_irb->scsw.cmd.alcc = irb->scsw.cmd.alcc;
		/* Copy suppress suspend bit. */
		cdev_irb->scsw.cmd.ssi = irb->scsw.cmd.ssi;
	}

	/* Take care of the extended control bit and extended control word. */
	ccw_device_accumulate_ecw(cdev, irb);
	    
	/* Accumulate function control. */
	cdev_irb->scsw.cmd.fctl |= irb->scsw.cmd.fctl;
	/* Copy activity control. */
	cdev_irb->scsw.cmd.actl = irb->scsw.cmd.actl;
	/* Accumulate status control. */
	cdev_irb->scsw.cmd.stctl |= irb->scsw.cmd.stctl;
	/*
	 * Copy ccw address if it is valid. This is a bit simplified
	 * but should be close enough for all practical purposes.
	 */
	if ((irb->scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) ||
	    ((irb->scsw.cmd.stctl ==
	      (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND)) &&
	     (irb->scsw.cmd.actl & SCSW_ACTL_DEVACT) &&
	     (irb->scsw.cmd.actl & SCSW_ACTL_SCHACT)) ||
	    (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
		cdev_irb->scsw.cmd.cpa = irb->scsw.cmd.cpa;
	/* Accumulate device status, but not the device busy flag. */
	cdev_irb->scsw.cmd.dstat &= ~DEV_STAT_BUSY;
	/* dstat is not always valid. */
	if (irb->scsw.cmd.stctl &
	    (SCSW_STCTL_PRIM_STATUS | SCSW_STCTL_SEC_STATUS
	     | SCSW_STCTL_INTER_STATUS | SCSW_STCTL_ALERT_STATUS))
		cdev_irb->scsw.cmd.dstat |= irb->scsw.cmd.dstat;
	/* Accumulate subchannel status. */
	cdev_irb->scsw.cmd.cstat |= irb->scsw.cmd.cstat;
	/* Copy residual count if it is valid. */
	if ((irb->scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) &&
	    (irb->scsw.cmd.cstat & ~(SCHN_STAT_PCI | SCHN_STAT_INCORR_LEN))
	     == 0)
		cdev_irb->scsw.cmd.count = irb->scsw.cmd.count;

	/* Take care of bits in the extended status word. */
	ccw_device_accumulate_esw(cdev, irb);

	/*
	 * Check whether we must issue a SENSE CCW ourselves if there is no
	 * concurrent sense facility installed for the subchannel.
	 * No sense is required if no delayed sense is pending
	 * and we did not get a unit check without sense information.
	 *
	 * Note: We should check for ioinfo[irq]->flags.consns but VM
	 *	 violates the ESA/390 architecture and doesn't present an
	 *	 operand exception for virtual devices without concurrent
	 *	 sense facility available/supported when enabling the
	 *	 concurrent sense facility.
	 */
	if ((cdev_irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
	    !(cdev_irb->esw.esw0.erw.cons))
		cdev->private->flags.dosense = 1;
}

/*
 * Do a basic sense.
 */
int
ccw_device_do_sense(struct ccw_device *cdev, struct irb *irb)
{
	struct subchannel *sch;
	struct ccw1 *sense_ccw;
	int rc;

	sch = to_subchannel(cdev->dev.parent);

	/* A sense is required, can we do it now ? */
	if (scsw_actl(&irb->scsw) & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT))
		/*
		 * we received an Unit Check but we have no final
		 *  status yet, therefore we must delay the SENSE
		 *  processing. We must not report this intermediate
		 *  status to the device interrupt handler.
		 */
		return -EBUSY;

	/*
	 * We have ending status but no sense information. Do a basic sense.
	 */
	sense_ccw = &to_io_private(sch)->sense_ccw;
	sense_ccw->cmd_code = CCW_CMD_BASIC_SENSE;
	sense_ccw->cda = (__u32) __pa(cdev->private->irb.ecw);
	sense_ccw->count = SENSE_MAX_COUNT;
	sense_ccw->flags = CCW_FLAG_SLI;

	rc = cio_start(sch, sense_ccw, 0xff);
	if (rc == -ENODEV || rc == -EACCES)
		dev_fsm_event(cdev, DEV_EVENT_VERIFY);
	return rc;
}

/*
 * Add information from basic sense to devstat.
 */
void
ccw_device_accumulate_basic_sense(struct ccw_device *cdev, struct irb *irb)
{
	/*
	 * Check if the status pending bit is set in stctl.
	 * If not, the remaining bit have no meaning and we must ignore them.
	 * The esw is not meaningful as well...
	 */
	if (!(scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))
		return;

	/* Check for channel checks and interface control checks. */
	ccw_device_msg_control_check(cdev, irb);

	/* Check for path not operational. */
	if (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw))
		ccw_device_path_notoper(cdev);

	if (!(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
	    (irb->scsw.cmd.dstat & DEV_STAT_CHN_END)) {
		cdev->private->irb.esw.esw0.erw.cons = 1;
		cdev->private->flags.dosense = 0;
	}
	/* Check if path verification is required. */
	if (ccw_device_accumulate_esw_valid(irb) &&
	    irb->esw.esw0.erw.pvrf)
		cdev->private->flags.doverify = 1;
}

/*
 * This function accumulates the status into the private devstat and
 * starts a basic sense if one is needed.
 */
int
ccw_device_accumulate_and_sense(struct ccw_device *cdev, struct irb *irb)
{
	ccw_device_accumulate_irb(cdev, irb);
	if ((irb->scsw.cmd.actl  & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0)
		return -EBUSY;
	/* Check for basic sense. */
	if (cdev->private->flags.dosense &&
	    !(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)) {
		cdev->private->irb.esw.esw0.erw.cons = 1;
		cdev->private->flags.dosense = 0;
		return 0;
	}
	if (cdev->private->flags.dosense) {
		ccw_device_do_sense(cdev, irb);
		return -EBUSY;
	}
	return 0;
}
Commit	Line	Data
1da177e4	1	/*
a53c8fab	2	* Copyright IBM Corp. 2002
4ce3b30c	3	* Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
1da177e4 LT	4	* Martin Schwidefsky (schwidefsky@de.ibm.com)
	5	*
	6	* Status accumulation and basic sense functions.
	7	*/
	8
1da177e4 LT	9	#include <linux/module.h>
	10	#include <linux/init.h>
	11
	12	#include <asm/ccwdev.h>
	13	#include <asm/cio.h>
	14
	15	#include "cio.h"
	16	#include "cio_debug.h"
	17	#include "css.h"
	18	#include "device.h"
	19	#include "ioasm.h"
cd6b4f27	20	#include "io_sch.h"
1da177e4 LT	21
	22	/*
	23	* Check for any kind of channel or interface control check but don't
	24	* issue the message for the console device
	25	*/
4d284cac	26	static void
1da177e4 LT	27	ccw_device_msg_control_check(struct ccw_device cdev, struct irb irb)
1da177e4 LT	28	{
23d805b6 PO	29	char dbf_text[15];
	30
	31	if (!scsw_is_valid_cstat(&irb->scsw) \|\|
	32	!(scsw_cstat(&irb->scsw) & (SCHN_STAT_CHN_DATA_CHK \|
	33	SCHN_STAT_CHN_CTRL_CHK \| SCHN_STAT_INTF_CTRL_CHK)))
1da177e4	34	return;
1da177e4 LT	35	CIO_MSG_EVENT(0, "Channel-Check or Interface-Control-Check "
1da177e4 LT	36	"received"
fb6958a5	37	" ... device %04x on subchannel 0.%x.%04x, dev_stat "
1da177e4	38	": %02X sch_stat : %02X\n",
78964268 CH	39	cdev->private->dev_id.devno, cdev->private->schid.ssid,
78964268 CH	40	cdev->private->schid.sch_no,
23d805b6 PO	41	scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw));
	42	sprintf(dbf_text, "chk%x", cdev->private->schid.sch_no);
	43	CIO_TRACE_EVENT(0, dbf_text);
	44	CIO_HEX_EVENT(0, irb, sizeof(struct irb));
1da177e4 LT	45	}
	46
	47	/*
	48	* Some paths became not operational (pno bit in scsw is set).
	49	*/
	50	static void
	51	ccw_device_path_notoper(struct ccw_device *cdev)
	52	{
	53	struct subchannel *sch;
	54
	55	sch = to_subchannel(cdev->dev.parent);
cdb912a4 SO	56	if (cio_update_schib(sch))
cdb912a4 SO	57	goto doverify;
1da177e4	58
fb6958a5	59	CIO_MSG_EVENT(0, "%s(0.%x.%04x) - path(s) %02x are "
2a2cf6b1	60	"not operational \n", __func__,
fb6958a5	61	sch->schid.ssid, sch->schid.sch_no,
1da177e4 LT	62	sch->schib.pmcw.pnom);
	63
	64	sch->lpm &= ~sch->schib.pmcw.pnom;
cdb912a4	65	doverify:
7e560814	66	cdev->private->flags.doverify = 1;
1da177e4 LT	67	}
	68
	69	/*
	70	* Copy valid bits from the extended control word to device irb.
	71	*/
4d284cac	72	static void
1da177e4 LT	73	ccw_device_accumulate_ecw(struct ccw_device cdev, struct irb irb)
	74	{
	75	/*
	76	* Copy extended control bit if it is valid... yes there
	77	* are condition that have to be met for the extended control
	78	* bit to have meaning. Sick.
	79	*/
23d805b6 PO	80	cdev->private->irb.scsw.cmd.ectl = 0;
	81	if ((irb->scsw.cmd.stctl & SCSW_STCTL_ALERT_STATUS) &&
	82	!(irb->scsw.cmd.stctl & SCSW_STCTL_INTER_STATUS))
	83	cdev->private->irb.scsw.cmd.ectl = irb->scsw.cmd.ectl;
1da177e4	84	/* Check if extended control word is valid. */
23d805b6	85	if (!cdev->private->irb.scsw.cmd.ectl)
1da177e4 LT	86	return;
	87	/* Copy concurrent sense / model dependent information. */
	88	memcpy (&cdev->private->irb.ecw, irb->ecw, sizeof (irb->ecw));
	89	}
	90
	91	/*
	92	* Check if extended status word is valid.
	93	*/
4d284cac	94	static int
1da177e4 LT	95	ccw_device_accumulate_esw_valid(struct irb *irb)
1da177e4 LT	96	{
23d805b6 PO	97	if (!irb->scsw.cmd.eswf &&
23d805b6 PO	98	(irb->scsw.cmd.stctl == SCSW_STCTL_STATUS_PEND))
1da177e4	99	return 0;
23d805b6 PO	100	if (irb->scsw.cmd.stctl ==
	101	(SCSW_STCTL_INTER_STATUS\|SCSW_STCTL_STATUS_PEND) &&
	102	!(irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
1da177e4 LT	103	return 0;
	104	return 1;
	105	}
	106
	107	/*
	108	* Copy valid bits from the extended status word to device irb.
	109	*/
4d284cac	110	static void
1da177e4 LT	111	ccw_device_accumulate_esw(struct ccw_device cdev, struct irb irb)
	112	{
	113	struct irb *cdev_irb;
	114	struct sublog cdev_sublog, sublog;
	115
	116	if (!ccw_device_accumulate_esw_valid(irb))
	117	return;
	118
	119	cdev_irb = &cdev->private->irb;
	120
	121	/* Copy last path used mask. */
	122	cdev_irb->esw.esw1.lpum = irb->esw.esw1.lpum;
	123
	124	/* Copy subchannel logout information if esw is of format 0. */
23d805b6	125	if (irb->scsw.cmd.eswf) {
1da177e4 LT	126	cdev_sublog = &cdev_irb->esw.esw0.sublog;
	127	sublog = &irb->esw.esw0.sublog;
	128	/* Copy extended status flags. */
	129	cdev_sublog->esf = sublog->esf;
	130	/*
	131	* Copy fields that have a meaning for channel data check
	132	* channel control check and interface control check.
	133	*/
23d805b6	134	if (irb->scsw.cmd.cstat & (SCHN_STAT_CHN_DATA_CHK \|
1da177e4 LT	135	SCHN_STAT_CHN_CTRL_CHK \|
	136	SCHN_STAT_INTF_CTRL_CHK)) {
	137	/* Copy ancillary report bit. */
	138	cdev_sublog->arep = sublog->arep;
	139	/* Copy field-validity-flags. */
	140	cdev_sublog->fvf = sublog->fvf;
	141	/* Copy storage access code. */
	142	cdev_sublog->sacc = sublog->sacc;
	143	/* Copy termination code. */
	144	cdev_sublog->termc = sublog->termc;
	145	/* Copy sequence code. */
	146	cdev_sublog->seqc = sublog->seqc;
	147	}
	148	/* Copy device status check. */
	149	cdev_sublog->devsc = sublog->devsc;
	150	/* Copy secondary error. */
	151	cdev_sublog->serr = sublog->serr;
	152	/* Copy i/o-error alert. */
	153	cdev_sublog->ioerr = sublog->ioerr;
	154	/* Copy channel path timeout bit. */
23d805b6	155	if (irb->scsw.cmd.cstat & SCHN_STAT_INTF_CTRL_CHK)
1da177e4 LT	156	cdev_irb->esw.esw0.erw.cpt = irb->esw.esw0.erw.cpt;
	157	/* Copy failing storage address validity flag. */
	158	cdev_irb->esw.esw0.erw.fsavf = irb->esw.esw0.erw.fsavf;
	159	if (cdev_irb->esw.esw0.erw.fsavf) {
	160	/* ... and copy the failing storage address. */
	161	memcpy(cdev_irb->esw.esw0.faddr, irb->esw.esw0.faddr,
	162	sizeof (irb->esw.esw0.faddr));
	163	/* ... and copy the failing storage address format. */
	164	cdev_irb->esw.esw0.erw.fsaf = irb->esw.esw0.erw.fsaf;
	165	}
	166	/* Copy secondary ccw address validity bit. */
	167	cdev_irb->esw.esw0.erw.scavf = irb->esw.esw0.erw.scavf;
	168	if (irb->esw.esw0.erw.scavf)
	169	/* ... and copy the secondary ccw address. */
	170	cdev_irb->esw.esw0.saddr = irb->esw.esw0.saddr;
	171
	172	}
	173	/* FIXME: DCTI for format 2? */
	174
	175	/* Copy authorization bit. */
	176	cdev_irb->esw.esw0.erw.auth = irb->esw.esw0.erw.auth;
	177	/* Copy path verification required flag. */
	178	cdev_irb->esw.esw0.erw.pvrf = irb->esw.esw0.erw.pvrf;
7e560814	179	if (irb->esw.esw0.erw.pvrf)
1da177e4 LT	180	cdev->private->flags.doverify = 1;
	181	/* Copy concurrent sense bit. */
	182	cdev_irb->esw.esw0.erw.cons = irb->esw.esw0.erw.cons;
	183	if (irb->esw.esw0.erw.cons)
	184	cdev_irb->esw.esw0.erw.scnt = irb->esw.esw0.erw.scnt;
	185	}
	186
	187	/*
	188	* Accumulate status from irb to devstat.
	189	*/
	190	void
	191	ccw_device_accumulate_irb(struct ccw_device cdev, struct irb irb)
	192	{
	193	struct irb *cdev_irb;
	194
	195	/*
	196	* Check if the status pending bit is set in stctl.
	197	* If not, the remaining bit have no meaning and we must ignore them.
	198	* The esw is not meaningful as well...
	199	*/
23d805b6	200	if (!(scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))
1da177e4 LT	201	return;
	202
	203	/* Check for channel checks and interface control checks. */
	204	ccw_device_msg_control_check(cdev, irb);
	205
	206	/* Check for path not operational. */
23d805b6	207	if (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw))
1da177e4	208	ccw_device_path_notoper(cdev);
23d805b6 PO	209	/* No irb accumulation for transport mode irbs. */
	210	if (scsw_is_tm(&irb->scsw)) {
	211	memcpy(&cdev->private->irb, irb, sizeof(struct irb));
	212	return;
	213	}
1da177e4 LT	214	/*
	215	* Don't accumulate unsolicited interrupts.
	216	*/
23d805b6	217	if (!scsw_is_solicited(&irb->scsw))
1da177e4 LT	218	return;
	219
	220	cdev_irb = &cdev->private->irb;
	221
8c3ce5be CH	222	/*
	223	* If the clear function had been performed, all formerly pending
	224	* status at the subchannel has been cleared and we must not pass
	225	* intermediate accumulated status to the device driver.
	226	*/
23d805b6	227	if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
8c3ce5be CH	228	memset(&cdev->private->irb, 0, sizeof(struct irb));
8c3ce5be CH	229
1da177e4	230	/* Copy bits which are valid only for the start function. */
23d805b6	231	if (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) {
1da177e4	232	/* Copy key. */
23d805b6	233	cdev_irb->scsw.cmd.key = irb->scsw.cmd.key;
1da177e4	234	/* Copy suspend control bit. */
23d805b6	235	cdev_irb->scsw.cmd.sctl = irb->scsw.cmd.sctl;
1da177e4	236	/* Accumulate deferred condition code. */
23d805b6	237	cdev_irb->scsw.cmd.cc \|= irb->scsw.cmd.cc;
1da177e4	238	/* Copy ccw format bit. */
23d805b6	239	cdev_irb->scsw.cmd.fmt = irb->scsw.cmd.fmt;
1da177e4	240	/* Copy prefetch bit. */
23d805b6	241	cdev_irb->scsw.cmd.pfch = irb->scsw.cmd.pfch;
1da177e4	242	/* Copy initial-status-interruption-control. */
23d805b6	243	cdev_irb->scsw.cmd.isic = irb->scsw.cmd.isic;
1da177e4	244	/* Copy address limit checking control. */
23d805b6	245	cdev_irb->scsw.cmd.alcc = irb->scsw.cmd.alcc;
1da177e4	246	/* Copy suppress suspend bit. */
23d805b6	247	cdev_irb->scsw.cmd.ssi = irb->scsw.cmd.ssi;
1da177e4 LT	248	}
	249
	250	/* Take care of the extended control bit and extended control word. */
	251	ccw_device_accumulate_ecw(cdev, irb);
	252
	253	/* Accumulate function control. */
23d805b6	254	cdev_irb->scsw.cmd.fctl \|= irb->scsw.cmd.fctl;
1da177e4	255	/* Copy activity control. */
23d805b6	256	cdev_irb->scsw.cmd.actl = irb->scsw.cmd.actl;
1da177e4	257	/* Accumulate status control. */
23d805b6	258	cdev_irb->scsw.cmd.stctl \|= irb->scsw.cmd.stctl;
1da177e4 LT	259	/*
	260	* Copy ccw address if it is valid. This is a bit simplified
	261	* but should be close enough for all practical purposes.
	262	*/
23d805b6 PO	263	if ((irb->scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) \|\|
23d805b6 PO	264	((irb->scsw.cmd.stctl ==
1da177e4	265	(SCSW_STCTL_INTER_STATUS\|SCSW_STCTL_STATUS_PEND)) &&
23d805b6 PO	266	(irb->scsw.cmd.actl & SCSW_ACTL_DEVACT) &&
	267	(irb->scsw.cmd.actl & SCSW_ACTL_SCHACT)) \|\|
	268	(irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
	269	cdev_irb->scsw.cmd.cpa = irb->scsw.cmd.cpa;
1da177e4	270	/* Accumulate device status, but not the device busy flag. */
23d805b6	271	cdev_irb->scsw.cmd.dstat &= ~DEV_STAT_BUSY;
25c61a1f	272	/* dstat is not always valid. */
23d805b6	273	if (irb->scsw.cmd.stctl &
25c61a1f CH	274	(SCSW_STCTL_PRIM_STATUS \| SCSW_STCTL_SEC_STATUS
25c61a1f CH	275	\| SCSW_STCTL_INTER_STATUS \| SCSW_STCTL_ALERT_STATUS))
23d805b6	276	cdev_irb->scsw.cmd.dstat \|= irb->scsw.cmd.dstat;
1da177e4	277	/* Accumulate subchannel status. */
23d805b6	278	cdev_irb->scsw.cmd.cstat \|= irb->scsw.cmd.cstat;
1da177e4	279	/* Copy residual count if it is valid. */
23d805b6 PO	280	if ((irb->scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) &&
	281	(irb->scsw.cmd.cstat & ~(SCHN_STAT_PCI \| SCHN_STAT_INCORR_LEN))
	282	== 0)
	283	cdev_irb->scsw.cmd.count = irb->scsw.cmd.count;
1da177e4 LT	284
	285	/* Take care of bits in the extended status word. */
	286	ccw_device_accumulate_esw(cdev, irb);
	287
	288	/*
	289	* Check whether we must issue a SENSE CCW ourselves if there is no
	290	* concurrent sense facility installed for the subchannel.
	291	* No sense is required if no delayed sense is pending
	292	* and we did not get a unit check without sense information.
	293	*
	294	* Note: We should check for ioinfo[irq]->flags.consns but VM
	295	* violates the ESA/390 architecture and doesn't present an
	296	* operand exception for virtual devices without concurrent
	297	* sense facility available/supported when enabling the
	298	* concurrent sense facility.
	299	*/
23d805b6	300	if ((cdev_irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
1da177e4 LT	301	!(cdev_irb->esw.esw0.erw.cons))
	302	cdev->private->flags.dosense = 1;
	303	}
	304
	305	/*
	306	* Do a basic sense.
	307	*/
	308	int
	309	ccw_device_do_sense(struct ccw_device cdev, struct irb irb)
	310	{
	311	struct subchannel *sch;
cd6b4f27	312	struct ccw1 *sense_ccw;
fe6173d9	313	int rc;
1da177e4 LT	314
	315	sch = to_subchannel(cdev->dev.parent);
	316
	317	/* A sense is required, can we do it now ? */
23d805b6	318	if (scsw_actl(&irb->scsw) & (SCSW_ACTL_DEVACT \| SCSW_ACTL_SCHACT))
1da177e4 LT	319	/*
	320	* we received an Unit Check but we have no final
	321	* status yet, therefore we must delay the SENSE
	322	* processing. We must not report this intermediate
	323	* status to the device interrupt handler.
	324	*/
	325	return -EBUSY;
	326
	327	/*
	328	* We have ending status but no sense information. Do a basic sense.
	329	*/
cd6b4f27 CH	330	sense_ccw = &to_io_private(sch)->sense_ccw;
	331	sense_ccw->cmd_code = CCW_CMD_BASIC_SENSE;
	332	sense_ccw->cda = (__u32) __pa(cdev->private->irb.ecw);
	333	sense_ccw->count = SENSE_MAX_COUNT;
	334	sense_ccw->flags = CCW_FLAG_SLI;
1da177e4	335
fe6173d9 CH	336	rc = cio_start(sch, sense_ccw, 0xff);
	337	if (rc == -ENODEV \|\| rc == -EACCES)
	338	dev_fsm_event(cdev, DEV_EVENT_VERIFY);
	339	return rc;
1da177e4 LT	340	}
	341
	342	/*
	343	* Add information from basic sense to devstat.
	344	*/
	345	void
	346	ccw_device_accumulate_basic_sense(struct ccw_device cdev, struct irb irb)
	347	{
	348	/*
	349	* Check if the status pending bit is set in stctl.
	350	* If not, the remaining bit have no meaning and we must ignore them.
	351	* The esw is not meaningful as well...
	352	*/
23d805b6	353	if (!(scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))
1da177e4 LT	354	return;
	355
	356	/* Check for channel checks and interface control checks. */
	357	ccw_device_msg_control_check(cdev, irb);
	358
	359	/* Check for path not operational. */
23d805b6	360	if (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw))
1da177e4 LT	361	ccw_device_path_notoper(cdev);
1da177e4 LT	362
23d805b6 PO	363	if (!(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
23d805b6 PO	364	(irb->scsw.cmd.dstat & DEV_STAT_CHN_END)) {
1da177e4 LT	365	cdev->private->irb.esw.esw0.erw.cons = 1;
	366	cdev->private->flags.dosense = 0;
	367	}
	368	/* Check if path verification is required. */
	369	if (ccw_device_accumulate_esw_valid(irb) &&
7e560814	370	irb->esw.esw0.erw.pvrf)
1da177e4 LT	371	cdev->private->flags.doverify = 1;
	372	}
	373
	374	/*
	375	* This function accumulates the status into the private devstat and
	376	* starts a basic sense if one is needed.
	377	*/
	378	int
	379	ccw_device_accumulate_and_sense(struct ccw_device cdev, struct irb irb)
	380	{
	381	ccw_device_accumulate_irb(cdev, irb);
23d805b6	382	if ((irb->scsw.cmd.actl & (SCSW_ACTL_DEVACT \| SCSW_ACTL_SCHACT)) != 0)
1da177e4 LT	383	return -EBUSY;
	384	/* Check for basic sense. */
	385	if (cdev->private->flags.dosense &&
23d805b6	386	!(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)) {
1da177e4 LT	387	cdev->private->irb.esw.esw0.erw.cons = 1;
	388	cdev->private->flags.dosense = 0;
	389	return 0;
	390	}
	391	if (cdev->private->flags.dosense) {
	392	ccw_device_do_sense(cdev, irb);
	393	return -EBUSY;
	394	}
	395	return 0;
	396	}
	397