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