[deliverable/linux.git] / drivers / s390 / cio / device_status.c

/*
 * drivers/s390/cio/device_status.c
 *
 *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
 *			 IBM Corporation
 *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
 *		 Martin Schwidefsky (schwidefsky@de.ibm.com)
 *
 * Status accumulation and basic sense functions.
 */

#include <linux/config.h>
#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"

/*
 * Check for any kind of channel or interface control check but don't
 * issue the message for the console device
 */
static inline void
ccw_device_msg_control_check(struct ccw_device *cdev, struct irb *irb)
{
	if (!(irb->scsw.cstat & (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->devno, cdev->private->ssid,
		      cdev->private->sch_no,
		      irb->scsw.dstat, irb->scsw.cstat);

	if (irb->scsw.cc != 3) {
		char dbf_text[15];

		sprintf(dbf_text, "chk%x", cdev->private->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);
	stsch (sch->schid, &sch->schib);

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

	sch->lpm &= ~sch->schib.pmcw.pnom;
	if (cdev->private->options.pgroup)
		cdev->private->flags.doverify = 1;
}

/*
 * Copy valid bits from the extended control word to device irb.
 */
static inline 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.ectl = 0;
	if ((irb->scsw.stctl & SCSW_STCTL_ALERT_STATUS) &&
	    !(irb->scsw.stctl & SCSW_STCTL_INTER_STATUS))
		cdev->private->irb.scsw.ectl = irb->scsw.ectl;
	/* Check if extended control word is valid. */
	if (!cdev->private->irb.scsw.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 inline int
ccw_device_accumulate_esw_valid(struct irb *irb)
{
	if (!irb->scsw.eswf && irb->scsw.stctl == SCSW_STCTL_STATUS_PEND)
		return 0;
	if (irb->scsw.stctl == 
	    		(SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND) &&
	    !(irb->scsw.actl & SCSW_ACTL_SUSPENDED))
		return 0;
	return 1;
}

/*
 * Copy valid bits from the extended status word to device irb.
 */
static inline 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.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.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.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->options.pgroup)
		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 (!(irb->scsw.stctl & 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 (irb->scsw.pno && irb->scsw.fctl != 0 &&
	    (!(irb->scsw.stctl & SCSW_STCTL_INTER_STATUS) ||
	     (irb->scsw.actl & SCSW_ACTL_SUSPENDED)))
		ccw_device_path_notoper(cdev);

	/*
	 * Don't accumulate unsolicited interrupts.
	 */
	if ((irb->scsw.stctl ==
	     (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) &&
	    (!irb->scsw.cc))
		return;

	cdev_irb = &cdev->private->irb;

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

	/* Take care of the extended control bit and extended control word. */
	ccw_device_accumulate_ecw(cdev, irb);
	    
	/* Accumulate function control. */
	cdev_irb->scsw.fctl |= irb->scsw.fctl;
	/* Copy activity control. */
	cdev_irb->scsw.actl= irb->scsw.actl;
	/* Accumulate status control. */
	cdev_irb->scsw.stctl |= irb->scsw.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.stctl & SCSW_STCTL_PRIM_STATUS) ||
	    ((irb->scsw.stctl == 
	      (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND)) &&
	     (irb->scsw.actl & SCSW_ACTL_DEVACT) &&
	     (irb->scsw.actl & SCSW_ACTL_SCHACT)) ||
	    (irb->scsw.actl & SCSW_ACTL_SUSPENDED))
		cdev_irb->scsw.cpa = irb->scsw.cpa;
	/* Accumulate device status, but not the device busy flag. */
	cdev_irb->scsw.dstat &= ~DEV_STAT_BUSY;
	cdev_irb->scsw.dstat |= irb->scsw.dstat;
	/* Accumulate subchannel status. */
	cdev_irb->scsw.cstat |= irb->scsw.cstat;
	/* Copy residual count if it is valid. */
	if ((irb->scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
	    (irb->scsw.cstat & ~(SCHN_STAT_PCI | SCHN_STAT_INCORR_LEN)) == 0)
		cdev_irb->scsw.count = irb->scsw.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.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;

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

	/* A sense is required, can we do it now ? */
	if ((irb->scsw.actl  & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0)
		/*
		 * 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.
	 */
	sch->sense_ccw.cmd_code = CCW_CMD_BASIC_SENSE;
	sch->sense_ccw.cda = (__u32) __pa(cdev->private->irb.ecw);
	sch->sense_ccw.count = SENSE_MAX_COUNT;
	sch->sense_ccw.flags = CCW_FLAG_SLI;

	return cio_start (sch, &sch->sense_ccw, 0xff);
}

/*
 * 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 (!(irb->scsw.stctl & 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 (irb->scsw.pno && irb->scsw.fctl != 0 &&
	    (!(irb->scsw.stctl & SCSW_STCTL_INTER_STATUS) ||
	     (irb->scsw.actl & SCSW_ACTL_SUSPENDED)))
		ccw_device_path_notoper(cdev);

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