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