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