Merge branch 'r6040-next'
[linux/fpc-iii.git] / drivers / s390 / cio / device_status.c
blob15b56a15db151cf4cfdfbc1e251a57400fb0706c
1 /*
2 * Copyright IBM Corp. 2002
3 * Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
4 * Martin Schwidefsky (schwidefsky@de.ibm.com)
6 * Status accumulation and basic sense functions.
7 */
9 #include <linux/module.h>
10 #include <linux/init.h>
12 #include <asm/ccwdev.h>
13 #include <asm/cio.h>
15 #include "cio.h"
16 #include "cio_debug.h"
17 #include "css.h"
18 #include "device.h"
19 #include "ioasm.h"
20 #include "io_sch.h"
23 * Check for any kind of channel or interface control check but don't
24 * issue the message for the console device
26 static void
27 ccw_device_msg_control_check(struct ccw_device *cdev, struct irb *irb)
29 char dbf_text[15];
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)))
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 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));
48 * Some paths became not operational (pno bit in scsw is set).
50 static void
51 ccw_device_path_notoper(struct ccw_device *cdev)
53 struct subchannel *sch;
55 sch = to_subchannel(cdev->dev.parent);
56 if (cio_update_schib(sch))
57 goto doverify;
59 CIO_MSG_EVENT(0, "%s(0.%x.%04x) - path(s) %02x are "
60 "not operational \n", __func__,
61 sch->schid.ssid, sch->schid.sch_no,
62 sch->schib.pmcw.pnom);
64 sch->lpm &= ~sch->schib.pmcw.pnom;
65 doverify:
66 cdev->private->flags.doverify = 1;
70 * Copy valid bits from the extended control word to device irb.
72 static void
73 ccw_device_accumulate_ecw(struct ccw_device *cdev, struct irb *irb)
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.
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;
84 /* Check if extended control word is valid. */
85 if (!cdev->private->irb.scsw.cmd.ectl)
86 return;
87 /* Copy concurrent sense / model dependent information. */
88 memcpy (&cdev->private->irb.ecw, irb->ecw, sizeof (irb->ecw));
92 * Check if extended status word is valid.
94 static int
95 ccw_device_accumulate_esw_valid(struct irb *irb)
97 if (!irb->scsw.cmd.eswf &&
98 (irb->scsw.cmd.stctl == SCSW_STCTL_STATUS_PEND))
99 return 0;
100 if (irb->scsw.cmd.stctl ==
101 (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND) &&
102 !(irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
103 return 0;
104 return 1;
108 * Copy valid bits from the extended status word to device irb.
110 static void
111 ccw_device_accumulate_esw(struct ccw_device *cdev, struct irb *irb)
113 struct irb *cdev_irb;
114 struct sublog *cdev_sublog, *sublog;
116 if (!ccw_device_accumulate_esw_valid(irb))
117 return;
119 cdev_irb = &cdev->private->irb;
121 /* Copy last path used mask. */
122 cdev_irb->esw.esw1.lpum = irb->esw.esw1.lpum;
124 /* Copy subchannel logout information if esw is of format 0. */
125 if (irb->scsw.cmd.eswf) {
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;
131 * Copy fields that have a meaning for channel data check
132 * channel control check and interface control check.
134 if (irb->scsw.cmd.cstat & (SCHN_STAT_CHN_DATA_CHK |
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;
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. */
155 if (irb->scsw.cmd.cstat & SCHN_STAT_INTF_CTRL_CHK)
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;
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;
173 /* FIXME: DCTI for format 2? */
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;
179 if (irb->esw.esw0.erw.pvrf)
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;
188 * Accumulate status from irb to devstat.
190 void
191 ccw_device_accumulate_irb(struct ccw_device *cdev, struct irb *irb)
193 struct irb *cdev_irb;
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...
200 if (!(scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))
201 return;
203 /* Check for channel checks and interface control checks. */
204 ccw_device_msg_control_check(cdev, irb);
206 /* Check for path not operational. */
207 if (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw))
208 ccw_device_path_notoper(cdev);
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;
215 * Don't accumulate unsolicited interrupts.
217 if (!scsw_is_solicited(&irb->scsw))
218 return;
220 cdev_irb = &cdev->private->irb;
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.
227 if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
228 memset(&cdev->private->irb, 0, sizeof(struct irb));
230 /* Copy bits which are valid only for the start function. */
231 if (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) {
232 /* Copy key. */
233 cdev_irb->scsw.cmd.key = irb->scsw.cmd.key;
234 /* Copy suspend control bit. */
235 cdev_irb->scsw.cmd.sctl = irb->scsw.cmd.sctl;
236 /* Accumulate deferred condition code. */
237 cdev_irb->scsw.cmd.cc |= irb->scsw.cmd.cc;
238 /* Copy ccw format bit. */
239 cdev_irb->scsw.cmd.fmt = irb->scsw.cmd.fmt;
240 /* Copy prefetch bit. */
241 cdev_irb->scsw.cmd.pfch = irb->scsw.cmd.pfch;
242 /* Copy initial-status-interruption-control. */
243 cdev_irb->scsw.cmd.isic = irb->scsw.cmd.isic;
244 /* Copy address limit checking control. */
245 cdev_irb->scsw.cmd.alcc = irb->scsw.cmd.alcc;
246 /* Copy suppress suspend bit. */
247 cdev_irb->scsw.cmd.ssi = irb->scsw.cmd.ssi;
250 /* Take care of the extended control bit and extended control word. */
251 ccw_device_accumulate_ecw(cdev, irb);
253 /* Accumulate function control. */
254 cdev_irb->scsw.cmd.fctl |= irb->scsw.cmd.fctl;
255 /* Copy activity control. */
256 cdev_irb->scsw.cmd.actl = irb->scsw.cmd.actl;
257 /* Accumulate status control. */
258 cdev_irb->scsw.cmd.stctl |= irb->scsw.cmd.stctl;
260 * Copy ccw address if it is valid. This is a bit simplified
261 * but should be close enough for all practical purposes.
263 if ((irb->scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) ||
264 ((irb->scsw.cmd.stctl ==
265 (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND)) &&
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;
270 /* Accumulate device status, but not the device busy flag. */
271 cdev_irb->scsw.cmd.dstat &= ~DEV_STAT_BUSY;
272 /* dstat is not always valid. */
273 if (irb->scsw.cmd.stctl &
274 (SCSW_STCTL_PRIM_STATUS | SCSW_STCTL_SEC_STATUS
275 | SCSW_STCTL_INTER_STATUS | SCSW_STCTL_ALERT_STATUS))
276 cdev_irb->scsw.cmd.dstat |= irb->scsw.cmd.dstat;
277 /* Accumulate subchannel status. */
278 cdev_irb->scsw.cmd.cstat |= irb->scsw.cmd.cstat;
279 /* Copy residual count if it is valid. */
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;
285 /* Take care of bits in the extended status word. */
286 ccw_device_accumulate_esw(cdev, irb);
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.
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.
300 if ((cdev_irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
301 !(cdev_irb->esw.esw0.erw.cons))
302 cdev->private->flags.dosense = 1;
306 * Do a basic sense.
309 ccw_device_do_sense(struct ccw_device *cdev, struct irb *irb)
311 struct subchannel *sch;
312 struct ccw1 *sense_ccw;
313 int rc;
315 sch = to_subchannel(cdev->dev.parent);
317 /* A sense is required, can we do it now ? */
318 if (scsw_actl(&irb->scsw) & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT))
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.
325 return -EBUSY;
328 * We have ending status but no sense information. Do a basic sense.
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;
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;
343 * Add information from basic sense to devstat.
345 void
346 ccw_device_accumulate_basic_sense(struct ccw_device *cdev, struct irb *irb)
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...
353 if (!(scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))
354 return;
356 /* Check for channel checks and interface control checks. */
357 ccw_device_msg_control_check(cdev, irb);
359 /* Check for path not operational. */
360 if (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw))
361 ccw_device_path_notoper(cdev);
363 if (!(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
364 (irb->scsw.cmd.dstat & DEV_STAT_CHN_END)) {
365 cdev->private->irb.esw.esw0.erw.cons = 1;
366 cdev->private->flags.dosense = 0;
368 /* Check if path verification is required. */
369 if (ccw_device_accumulate_esw_valid(irb) &&
370 irb->esw.esw0.erw.pvrf)
371 cdev->private->flags.doverify = 1;
375 * This function accumulates the status into the private devstat and
376 * starts a basic sense if one is needed.
379 ccw_device_accumulate_and_sense(struct ccw_device *cdev, struct irb *irb)
381 ccw_device_accumulate_irb(cdev, irb);
382 if ((irb->scsw.cmd.actl & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0)
383 return -EBUSY;
384 /* Check for basic sense. */
385 if (cdev->private->flags.dosense &&
386 !(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)) {
387 cdev->private->irb.esw.esw0.erw.cons = 1;
388 cdev->private->flags.dosense = 0;
389 return 0;
391 if (cdev->private->flags.dosense) {
392 ccw_device_do_sense(cdev, irb);
393 return -EBUSY;
395 return 0;