?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[NETFILTER]: Move ip6_masked_addrcmp to include/net/ipv6.h
[linux-2.6/verdex.git] / drivers / s390 / block / dasd_3990_erp.c
blob4ee0f934e325388c779e20c05e32098b55ebe1ce
1 /*
2 * File...........: linux/drivers/s390/block/dasd_3990_erp.c
3 * Author(s)......: Horst Hummel <Horst.Hummel@de.ibm.com>
4 * Holger Smolinski <Holger.Smolinski@de.ibm.com>
5 * Bugreports.to..: <Linux390@de.ibm.com>
6 * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 2000, 2001
7 *
8 */
9
10 #include <linux/timer.h>
11 #include <linux/slab.h>
12 #include <asm/idals.h>
13 #include <asm/todclk.h>
14
15 #define PRINTK_HEADER "dasd_erp(3990): "
16
17 #include "dasd_int.h"
18 #include "dasd_eckd.h"
19
20
21 struct DCTL_data {
22 unsigned char subcommand; /* e.g Inhibit Write, Enable Write,... */
23 unsigned char modifier; /* Subcommand modifier */
24 unsigned short res; /* reserved */
25 } __attribute__ ((packed));
26
27 /*
28 *****************************************************************************
29 * SECTION ERP EXAMINATION
30 *****************************************************************************
31 */
32
33 /*
34 * DASD_3990_ERP_EXAMINE_24
35 *
36 * DESCRIPTION
37 * Checks only for fatal (unrecoverable) error.
38 * A detailed examination of the sense data is done later outside
39 * the interrupt handler.
40 *
41 * Each bit configuration leading to an action code 2 (Exit with
42 * programming error or unusual condition indication)
43 * are handled as fatal error´s.
44 *
45 * All other configurations are handled as recoverable errors.
46 *
47 * RETURN VALUES
48 * dasd_era_fatal for all fatal (unrecoverable errors)
49 * dasd_era_recover for all others.
50 */
51 static dasd_era_t
52 dasd_3990_erp_examine_24(struct dasd_ccw_req * cqr, char *sense)
53 {
54
55 struct dasd_device *device = cqr->device;
56
57 /* check for 'Command Reject' */
58 if ((sense[0] & SNS0_CMD_REJECT) &&
59 (!(sense[2] & SNS2_ENV_DATA_PRESENT))) {
60
61 DEV_MESSAGE(KERN_ERR, device, "%s",
62 "EXAMINE 24: Command Reject detected - "
63 "fatal error");
64
65 return dasd_era_fatal;
66 }
67
68 /* check for 'Invalid Track Format' */
69 if ((sense[1] & SNS1_INV_TRACK_FORMAT) &&
70 (!(sense[2] & SNS2_ENV_DATA_PRESENT))) {
71
72 DEV_MESSAGE(KERN_ERR, device, "%s",
73 "EXAMINE 24: Invalid Track Format detected "
74 "- fatal error");
75
76 return dasd_era_fatal;
77 }
78
79 /* check for 'No Record Found' */
80 if (sense[1] & SNS1_NO_REC_FOUND) {
81
82 /* FIXME: fatal error ?!? */
83 DEV_MESSAGE(KERN_ERR, device,
84 "EXAMINE 24: No Record Found detected %s",
85 device->state <= DASD_STATE_BASIC ?
86 " " : "- fatal error");
87
88 return dasd_era_fatal;
89 }
90
91 /* return recoverable for all others */
92 return dasd_era_recover;
93 } /* END dasd_3990_erp_examine_24 */
94
95 /*
96 * DASD_3990_ERP_EXAMINE_32
97 *
98 * DESCRIPTION
99 * Checks only for fatal/no/recoverable error.
100 * A detailed examination of the sense data is done later outside
101 * the interrupt handler.
102 *
103 * RETURN VALUES
104 * dasd_era_none no error
105 * dasd_era_fatal for all fatal (unrecoverable errors)
106 * dasd_era_recover for recoverable others.
107 */
108 static dasd_era_t
109 dasd_3990_erp_examine_32(struct dasd_ccw_req * cqr, char *sense)
110 {
111
112 struct dasd_device *device = cqr->device;
113
114 switch (sense[25]) {
115 case 0x00:
116 return dasd_era_none;
117
118 case 0x01:
119 DEV_MESSAGE(KERN_ERR, device, "%s", "EXAMINE 32: fatal error");
120
121 return dasd_era_fatal;
122
123 default:
124
125 return dasd_era_recover;
126 }
127
128 } /* end dasd_3990_erp_examine_32 */
129
130 /*
131 * DASD_3990_ERP_EXAMINE
132 *
133 * DESCRIPTION
134 * Checks only for fatal/no/recover error.
135 * A detailed examination of the sense data is done later outside
136 * the interrupt handler.
137 *
138 * The logic is based on the 'IBM 3990 Storage Control Reference' manual
139 * 'Chapter 7. Error Recovery Procedures'.
140 *
141 * RETURN VALUES
142 * dasd_era_none no error
143 * dasd_era_fatal for all fatal (unrecoverable errors)
144 * dasd_era_recover for all others.
145 */
146 dasd_era_t
147 dasd_3990_erp_examine(struct dasd_ccw_req * cqr, struct irb * irb)
148 {
149
150 char *sense = irb->ecw;
151 dasd_era_t era = dasd_era_recover;
152 struct dasd_device *device = cqr->device;
153
154 /* check for successful execution first */
155 if (irb->scsw.cstat == 0x00 &&
156 irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
157 return dasd_era_none;
158
159 /* distinguish between 24 and 32 byte sense data */
160 if (sense[27] & DASD_SENSE_BIT_0) {
161
162 era = dasd_3990_erp_examine_24(cqr, sense);
163
164 } else {
165
166 era = dasd_3990_erp_examine_32(cqr, sense);
167
168 }
169
170 /* log the erp chain if fatal error occurred */
171 if ((era == dasd_era_fatal) && (device->state >= DASD_STATE_READY)) {
172 dasd_log_sense(cqr, irb);
173 dasd_log_ccw(cqr, 0, irb->scsw.cpa);
174 }
175
176 return era;
177
178 } /* END dasd_3990_erp_examine */
179
180 /*
181 *****************************************************************************
182 * SECTION ERP HANDLING
183 *****************************************************************************
184 */
185 /*
186 *****************************************************************************
187 * 24 and 32 byte sense ERP functions
188 *****************************************************************************
189 */
190
191 /*
192 * DASD_3990_ERP_CLEANUP
193 *
194 * DESCRIPTION
195 * Removes the already build but not necessary ERP request and sets
196 * the status of the original cqr / erp to the given (final) status
197 *
198 * PARAMETER
199 * erp request to be blocked
200 * final_status either DASD_CQR_DONE or DASD_CQR_FAILED
201 *
202 * RETURN VALUES
203 * cqr original cqr
204 */
205 static struct dasd_ccw_req *
206 dasd_3990_erp_cleanup(struct dasd_ccw_req * erp, char final_status)
207 {
208 struct dasd_ccw_req *cqr = erp->refers;
209
210 dasd_free_erp_request(erp, erp->device);
211 cqr->status = final_status;
212 return cqr;
213
214 } /* end dasd_3990_erp_cleanup */
215
216 /*
217 * DASD_3990_ERP_BLOCK_QUEUE
218 *
219 * DESCRIPTION
220 * Block the given device request queue to prevent from further
221 * processing until the started timer has expired or an related
222 * interrupt was received.
223 */
224 static void
225 dasd_3990_erp_block_queue(struct dasd_ccw_req * erp, int expires)
226 {
227
228 struct dasd_device *device = erp->device;
229
230 DEV_MESSAGE(KERN_INFO, device,
231 "blocking request queue for %is", expires/HZ);
232
233 device->stopped |= DASD_STOPPED_PENDING;
234 erp->status = DASD_CQR_QUEUED;
235
236 dasd_set_timer(device, expires);
237 }
238
239 /*
240 * DASD_3990_ERP_INT_REQ
241 *
242 * DESCRIPTION
243 * Handles 'Intervention Required' error.
244 * This means either device offline or not installed.
245 *
246 * PARAMETER
247 * erp current erp
248 * RETURN VALUES
249 * erp modified erp
250 */
251 static struct dasd_ccw_req *
252 dasd_3990_erp_int_req(struct dasd_ccw_req * erp)
253 {
254
255 struct dasd_device *device = erp->device;
256
257 /* first time set initial retry counter and erp_function */
258 /* and retry once without blocking queue */
259 /* (this enables easier enqueing of the cqr) */
260 if (erp->function != dasd_3990_erp_int_req) {
261
262 erp->retries = 256;
263 erp->function = dasd_3990_erp_int_req;
264
265 } else {
266
267 /* issue a message and wait for 'device ready' interrupt */
268 DEV_MESSAGE(KERN_ERR, device, "%s",
269 "is offline or not installed - "
270 "INTERVENTION REQUIRED!!");
271
272 dasd_3990_erp_block_queue(erp, 60*HZ);
273 }
274
275 return erp;
276
277 } /* end dasd_3990_erp_int_req */
278
279 /*
280 * DASD_3990_ERP_ALTERNATE_PATH
281 *
282 * DESCRIPTION
283 * Repeat the operation on a different channel path.
284 * If all alternate paths have been tried, the request is posted with a
285 * permanent error.
286 *
287 * PARAMETER
288 * erp pointer to the current ERP
289 *
290 * RETURN VALUES
291 * erp modified pointer to the ERP
292 */
293 static void
294 dasd_3990_erp_alternate_path(struct dasd_ccw_req * erp)
295 {
296 struct dasd_device *device = erp->device;
297 __u8 opm;
298
299 /* try alternate valid path */
300 opm = ccw_device_get_path_mask(device->cdev);
301 //FIXME: start with get_opm ?
302 if (erp->lpm == 0)
303 erp->lpm = LPM_ANYPATH & ~(erp->irb.esw.esw0.sublog.lpum);
304 else
305 erp->lpm &= ~(erp->irb.esw.esw0.sublog.lpum);
306
307 if ((erp->lpm & opm) != 0x00) {
308
309 DEV_MESSAGE(KERN_DEBUG, device,
310 "try alternate lpm=%x (lpum=%x / opm=%x)",
311 erp->lpm, erp->irb.esw.esw0.sublog.lpum, opm);
312
313 /* reset status to queued to handle the request again... */
314 if (erp->status > DASD_CQR_QUEUED)
315 erp->status = DASD_CQR_QUEUED;
316 erp->retries = 1;
317 } else {
318 DEV_MESSAGE(KERN_ERR, device,
319 "No alternate channel path left (lpum=%x / "
320 "opm=%x) -> permanent error",
321 erp->irb.esw.esw0.sublog.lpum, opm);
322
323 /* post request with permanent error */
324 if (erp->status > DASD_CQR_QUEUED)
325 erp->status = DASD_CQR_FAILED;
326 }
327 } /* end dasd_3990_erp_alternate_path */
328
329 /*
330 * DASD_3990_ERP_DCTL
331 *
332 * DESCRIPTION
333 * Setup cqr to do the Diagnostic Control (DCTL) command with an
334 * Inhibit Write subcommand (0x20) and the given modifier.
335 *
336 * PARAMETER
337 * erp pointer to the current (failed) ERP
338 * modifier subcommand modifier
339 *
340 * RETURN VALUES
341 * dctl_cqr pointer to NEW dctl_cqr
342 *
343 */
344 static struct dasd_ccw_req *
345 dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier)
346 {
347
348 struct dasd_device *device = erp->device;
349 struct DCTL_data *DCTL_data;
350 struct ccw1 *ccw;
351 struct dasd_ccw_req *dctl_cqr;
352
353 dctl_cqr = dasd_alloc_erp_request((char *) &erp->magic, 1,
354 sizeof (struct DCTL_data),
355 erp->device);
356 if (IS_ERR(dctl_cqr)) {
357 DEV_MESSAGE(KERN_ERR, device, "%s",
358 "Unable to allocate DCTL-CQR");
359 erp->status = DASD_CQR_FAILED;
360 return erp;
361 }
362
363 DCTL_data = dctl_cqr->data;
364
365 DCTL_data->subcommand = 0x02; /* Inhibit Write */
366 DCTL_data->modifier = modifier;
367
368 ccw = dctl_cqr->cpaddr;
369 memset(ccw, 0, sizeof (struct ccw1));
370 ccw->cmd_code = CCW_CMD_DCTL;
371 ccw->count = 4;
372 ccw->cda = (__u32)(addr_t) DCTL_data;
373 dctl_cqr->function = dasd_3990_erp_DCTL;
374 dctl_cqr->refers = erp;
375 dctl_cqr->device = erp->device;
376 dctl_cqr->magic = erp->magic;
377 dctl_cqr->expires = 5 * 60 * HZ;
378 dctl_cqr->retries = 2;
379
380 dctl_cqr->buildclk = get_clock();
381
382 dctl_cqr->status = DASD_CQR_FILLED;
383
384 return dctl_cqr;
385
386 } /* end dasd_3990_erp_DCTL */
387
388 /*
389 * DASD_3990_ERP_ACTION_1
390 *
391 * DESCRIPTION
392 * Setup ERP to do the ERP action 1 (see Reference manual).
393 * Repeat the operation on a different channel path.
394 * If all alternate paths have been tried, the request is posted with a
395 * permanent error.
396 * Note: duplex handling is not implemented (yet).
397 *
398 * PARAMETER
399 * erp pointer to the current ERP
400 *
401 * RETURN VALUES
402 * erp pointer to the ERP
403 *
404 */
405 static struct dasd_ccw_req *
406 dasd_3990_erp_action_1(struct dasd_ccw_req * erp)
407 {
408
409 erp->function = dasd_3990_erp_action_1;
410
411 dasd_3990_erp_alternate_path(erp);
412
413 return erp;
414
415 } /* end dasd_3990_erp_action_1 */
416
417 /*
418 * DASD_3990_ERP_ACTION_4
419 *
420 * DESCRIPTION
421 * Setup ERP to do the ERP action 4 (see Reference manual).
422 * Set the current request to PENDING to block the CQR queue for that device
423 * until the state change interrupt appears.
424 * Use a timer (20 seconds) to retry the cqr if the interrupt is still
425 * missing.
426 *
427 * PARAMETER
428 * sense sense data of the actual error
429 * erp pointer to the current ERP
430 *
431 * RETURN VALUES
432 * erp pointer to the ERP
433 *
434 */
435 static struct dasd_ccw_req *
436 dasd_3990_erp_action_4(struct dasd_ccw_req * erp, char *sense)
437 {
438
439 struct dasd_device *device = erp->device;
440
441 /* first time set initial retry counter and erp_function */
442 /* and retry once without waiting for state change pending */
443 /* interrupt (this enables easier enqueing of the cqr) */
444 if (erp->function != dasd_3990_erp_action_4) {
445
446 DEV_MESSAGE(KERN_INFO, device, "%s",
447 "dasd_3990_erp_action_4: first time retry");
448
449 erp->retries = 256;
450 erp->function = dasd_3990_erp_action_4;
451
452 } else {
453
454 if (sense[25] == 0x1D) { /* state change pending */
455
456 DEV_MESSAGE(KERN_INFO, device,
457 "waiting for state change pending "
458 "interrupt, %d retries left",
459 erp->retries);
460
461 dasd_3990_erp_block_queue(erp, 30*HZ);
462
463 } else if (sense[25] == 0x1E) { /* busy */
464 DEV_MESSAGE(KERN_INFO, device,
465 "busy - redriving request later, "
466 "%d retries left",
467 erp->retries);
468 dasd_3990_erp_block_queue(erp, HZ);
469 } else {
470
471 /* no state change pending - retry */
472 DEV_MESSAGE (KERN_INFO, device,
473 "redriving request immediately, "
474 "%d retries left",
475 erp->retries);
476 erp->status = DASD_CQR_QUEUED;
477 }
478 }
479
480 return erp;
481
482 } /* end dasd_3990_erp_action_4 */
483
484 /*
485 *****************************************************************************
486 * 24 byte sense ERP functions (only)
487 *****************************************************************************
488 */
489
490 /*
491 * DASD_3990_ERP_ACTION_5
492 *
493 * DESCRIPTION
494 * Setup ERP to do the ERP action 5 (see Reference manual).
495 * NOTE: Further handling is done in xxx_further_erp after the retries.
496 *
497 * PARAMETER
498 * erp pointer to the current ERP
499 *
500 * RETURN VALUES
501 * erp pointer to the ERP
502 *
503 */
504 static struct dasd_ccw_req *
505 dasd_3990_erp_action_5(struct dasd_ccw_req * erp)
506 {
507
508 /* first of all retry */
509 erp->retries = 10;
510 erp->function = dasd_3990_erp_action_5;
511
512 return erp;
513
514 } /* end dasd_3990_erp_action_5 */
515
516 /*
517 * DASD_3990_HANDLE_ENV_DATA
518 *
519 * DESCRIPTION
520 * Handles 24 byte 'Environmental data present'.
521 * Does a analysis of the sense data (message Format)
522 * and prints the error messages.
523 *
524 * PARAMETER
525 * sense current sense data
526 *
527 * RETURN VALUES
528 * void
529 */
530 static void
531 dasd_3990_handle_env_data(struct dasd_ccw_req * erp, char *sense)
532 {
533
534 struct dasd_device *device = erp->device;
535 char msg_format = (sense[7] & 0xF0);
536 char msg_no = (sense[7] & 0x0F);
537
538 switch (msg_format) {
539 case 0x00: /* Format 0 - Program or System Checks */
540
541 if (sense[1] & 0x10) { /* check message to operator bit */
542
543 switch (msg_no) {
544 case 0x00: /* No Message */
545 break;
546 case 0x01:
547 DEV_MESSAGE(KERN_WARNING, device, "%s",
548 "FORMAT 0 - Invalid Command");
549 break;
550 case 0x02:
551 DEV_MESSAGE(KERN_WARNING, device, "%s",
552 "FORMAT 0 - Invalid Command "
553 "Sequence");
554 break;
555 case 0x03:
556 DEV_MESSAGE(KERN_WARNING, device, "%s",
557 "FORMAT 0 - CCW Count less than "
558 "required");
559 break;
560 case 0x04:
561 DEV_MESSAGE(KERN_WARNING, device, "%s",
562 "FORMAT 0 - Invalid Parameter");
563 break;
564 case 0x05:
565 DEV_MESSAGE(KERN_WARNING, device, "%s",
566 "FORMAT 0 - Diagnostic of Sepecial"
567 " Command Violates File Mask");
568 break;
569 case 0x07:
570 DEV_MESSAGE(KERN_WARNING, device, "%s",
571 "FORMAT 0 - Channel Returned with "
572 "Incorrect retry CCW");
573 break;
574 case 0x08:
575 DEV_MESSAGE(KERN_WARNING, device, "%s",
576 "FORMAT 0 - Reset Notification");
577 break;
578 case 0x09:
579 DEV_MESSAGE(KERN_WARNING, device, "%s",
580 "FORMAT 0 - Storage Path Restart");
581 break;
582 case 0x0A:
583 DEV_MESSAGE(KERN_WARNING, device,
584 "FORMAT 0 - Channel requested "
585 "... %02x", sense[8]);
586 break;
587 case 0x0B:
588 DEV_MESSAGE(KERN_WARNING, device, "%s",
589 "FORMAT 0 - Invalid Defective/"
590 "Alternate Track Pointer");
591 break;
592 case 0x0C:
593 DEV_MESSAGE(KERN_WARNING, device, "%s",
594 "FORMAT 0 - DPS Installation "
595 "Check");
596 break;
597 case 0x0E:
598 DEV_MESSAGE(KERN_WARNING, device, "%s",
599 "FORMAT 0 - Command Invalid on "
600 "Secondary Address");
601 break;
602 case 0x0F:
603 DEV_MESSAGE(KERN_WARNING, device,
604 "FORMAT 0 - Status Not As "
605 "Required: reason %02x", sense[8]);
606 break;
607 default:
608 DEV_MESSAGE(KERN_WARNING, device, "%s",
609 "FORMAT 0 - Reseved");
610 }
611 } else {
612 switch (msg_no) {
613 case 0x00: /* No Message */
614 break;
615 case 0x01:
616 DEV_MESSAGE(KERN_WARNING, device, "%s",
617 "FORMAT 0 - Device Error Source");
618 break;
619 case 0x02:
620 DEV_MESSAGE(KERN_WARNING, device, "%s",
621 "FORMAT 0 - Reserved");
622 break;
623 case 0x03:
624 DEV_MESSAGE(KERN_WARNING, device,
625 "FORMAT 0 - Device Fenced - "
626 "device = %02x", sense[4]);
627 break;
628 case 0x04:
629 DEV_MESSAGE(KERN_WARNING, device, "%s",
630 "FORMAT 0 - Data Pinned for "
631 "Device");
632 break;
633 default:
634 DEV_MESSAGE(KERN_WARNING, device, "%s",
635 "FORMAT 0 - Reserved");
636 }
637 }
638 break;
639
640 case 0x10: /* Format 1 - Device Equipment Checks */
641 switch (msg_no) {
642 case 0x00: /* No Message */
643 break;
644 case 0x01:
645 DEV_MESSAGE(KERN_WARNING, device, "%s",
646 "FORMAT 1 - Device Status 1 not as "
647 "expected");
648 break;
649 case 0x03:
650 DEV_MESSAGE(KERN_WARNING, device, "%s",
651 "FORMAT 1 - Index missing");
652 break;
653 case 0x04:
654 DEV_MESSAGE(KERN_WARNING, device, "%s",
655 "FORMAT 1 - Interruption cannot be reset");
656 break;
657 case 0x05:
658 DEV_MESSAGE(KERN_WARNING, device, "%s",
659 "FORMAT 1 - Device did not respond to "
660 "selection");
661 break;
662 case 0x06:
663 DEV_MESSAGE(KERN_WARNING, device, "%s",
664 "FORMAT 1 - Device check-2 error or Set "
665 "Sector is not complete");
666 break;
667 case 0x07:
668 DEV_MESSAGE(KERN_WARNING, device, "%s",
669 "FORMAT 1 - Head address does not "
670 "compare");
671 break;
672 case 0x08:
673 DEV_MESSAGE(KERN_WARNING, device, "%s",
674 "FORMAT 1 - Device status 1 not valid");
675 break;
676 case 0x09:
677 DEV_MESSAGE(KERN_WARNING, device, "%s",
678 "FORMAT 1 - Device not ready");
679 break;
680 case 0x0A:
681 DEV_MESSAGE(KERN_WARNING, device, "%s",
682 "FORMAT 1 - Track physical address did "
683 "not compare");
684 break;
685 case 0x0B:
686 DEV_MESSAGE(KERN_WARNING, device, "%s",
687 "FORMAT 1 - Missing device address bit");
688 break;
689 case 0x0C:
690 DEV_MESSAGE(KERN_WARNING, device, "%s",
691 "FORMAT 1 - Drive motor switch is off");
692 break;
693 case 0x0D:
694 DEV_MESSAGE(KERN_WARNING, device, "%s",
695 "FORMAT 1 - Seek incomplete");
696 break;
697 case 0x0E:
698 DEV_MESSAGE(KERN_WARNING, device, "%s",
699 "FORMAT 1 - Cylinder address did not "
700 "compare");
701 break;
702 case 0x0F:
703 DEV_MESSAGE(KERN_WARNING, device, "%s",
704 "FORMAT 1 - Offset active cannot be "
705 "reset");
706 break;
707 default:
708 DEV_MESSAGE(KERN_WARNING, device, "%s",
709 "FORMAT 1 - Reserved");
710 }
711 break;
712
713 case 0x20: /* Format 2 - 3990 Equipment Checks */
714 switch (msg_no) {
715 case 0x08:
716 DEV_MESSAGE(KERN_WARNING, device, "%s",
717 "FORMAT 2 - 3990 check-2 error");
718 break;
719 case 0x0E:
720 DEV_MESSAGE(KERN_WARNING, device, "%s",
721 "FORMAT 2 - Support facility errors");
722 break;
723 case 0x0F:
724 DEV_MESSAGE(KERN_WARNING, device,
725 "FORMAT 2 - Microcode detected error %02x",
726 sense[8]);
727 break;
728 default:
729 DEV_MESSAGE(KERN_WARNING, device, "%s",
730 "FORMAT 2 - Reserved");
731 }
732 break;
733
734 case 0x30: /* Format 3 - 3990 Control Checks */
735 switch (msg_no) {
736 case 0x0F:
737 DEV_MESSAGE(KERN_WARNING, device, "%s",
738 "FORMAT 3 - Allegiance terminated");
739 break;
740 default:
741 DEV_MESSAGE(KERN_WARNING, device, "%s",
742 "FORMAT 3 - Reserved");
743 }
744 break;
745
746 case 0x40: /* Format 4 - Data Checks */
747 switch (msg_no) {
748 case 0x00:
749 DEV_MESSAGE(KERN_WARNING, device, "%s",
750 "FORMAT 4 - Home address area error");
751 break;
752 case 0x01:
753 DEV_MESSAGE(KERN_WARNING, device, "%s",
754 "FORMAT 4 - Count area error");
755 break;
756 case 0x02:
757 DEV_MESSAGE(KERN_WARNING, device, "%s",
758 "FORMAT 4 - Key area error");
759 break;
760 case 0x03:
761 DEV_MESSAGE(KERN_WARNING, device, "%s",
762 "FORMAT 4 - Data area error");
763 break;
764 case 0x04:
765 DEV_MESSAGE(KERN_WARNING, device, "%s",
766 "FORMAT 4 - No sync byte in home address "
767 "area");
768 break;
769 case 0x05:
770 DEV_MESSAGE(KERN_WARNING, device, "%s",
771 "FORMAT 4 - No sync byte in count address "
772 "area");
773 break;
774 case 0x06:
775 DEV_MESSAGE(KERN_WARNING, device, "%s",
776 "FORMAT 4 - No sync byte in key area");
777 break;
778 case 0x07:
779 DEV_MESSAGE(KERN_WARNING, device, "%s",
780 "FORMAT 4 - No sync byte in data area");
781 break;
782 case 0x08:
783 DEV_MESSAGE(KERN_WARNING, device, "%s",
784 "FORMAT 4 - Home address area error; "
785 "offset active");
786 break;
787 case 0x09:
788 DEV_MESSAGE(KERN_WARNING, device, "%s",
789 "FORMAT 4 - Count area error; offset "
790 "active");
791 break;
792 case 0x0A:
793 DEV_MESSAGE(KERN_WARNING, device, "%s",
794 "FORMAT 4 - Key area error; offset "
795 "active");
796 break;
797 case 0x0B:
798 DEV_MESSAGE(KERN_WARNING, device, "%s",
799 "FORMAT 4 - Data area error; "
800 "offset active");
801 break;
802 case 0x0C:
803 DEV_MESSAGE(KERN_WARNING, device, "%s",
804 "FORMAT 4 - No sync byte in home "
805 "address area; offset active");
806 break;
807 case 0x0D:
808 DEV_MESSAGE(KERN_WARNING, device, "%s",
809 "FORMAT 4 - No syn byte in count "
810 "address area; offset active");
811 break;
812 case 0x0E:
813 DEV_MESSAGE(KERN_WARNING, device, "%s",
814 "FORMAT 4 - No sync byte in key area; "
815 "offset active");
816 break;
817 case 0x0F:
818 DEV_MESSAGE(KERN_WARNING, device, "%s",
819 "FORMAT 4 - No syn byte in data area; "
820 "offset active");
821 break;
822 default:
823 DEV_MESSAGE(KERN_WARNING, device, "%s",
824 "FORMAT 4 - Reserved");
825 }
826 break;
827
828 case 0x50: /* Format 5 - Data Check with displacement information */
829 switch (msg_no) {
830 case 0x00:
831 DEV_MESSAGE(KERN_WARNING, device, "%s",
832 "FORMAT 5 - Data Check in the "
833 "home address area");
834 break;
835 case 0x01:
836 DEV_MESSAGE(KERN_WARNING, device, "%s",
837 "FORMAT 5 - Data Check in the count area");
838 break;
839 case 0x02:
840 DEV_MESSAGE(KERN_WARNING, device, "%s",
841 "FORMAT 5 - Data Check in the key area");
842 break;
843 case 0x03:
844 DEV_MESSAGE(KERN_WARNING, device, "%s",
845 "FORMAT 5 - Data Check in the data area");
846 break;
847 case 0x08:
848 DEV_MESSAGE(KERN_WARNING, device, "%s",
849 "FORMAT 5 - Data Check in the "
850 "home address area; offset active");
851 break;
852 case 0x09:
853 DEV_MESSAGE(KERN_WARNING, device, "%s",
854 "FORMAT 5 - Data Check in the count area; "
855 "offset active");
856 break;
857 case 0x0A:
858 DEV_MESSAGE(KERN_WARNING, device, "%s",
859 "FORMAT 5 - Data Check in the key area; "
860 "offset active");
861 break;
862 case 0x0B:
863 DEV_MESSAGE(KERN_WARNING, device, "%s",
864 "FORMAT 5 - Data Check in the data area; "
865 "offset active");
866 break;
867 default:
868 DEV_MESSAGE(KERN_WARNING, device, "%s",
869 "FORMAT 5 - Reserved");
870 }
871 break;
872
873 case 0x60: /* Format 6 - Usage Statistics/Overrun Errors */
874 switch (msg_no) {
875 case 0x00:
876 DEV_MESSAGE(KERN_WARNING, device, "%s",
877 "FORMAT 6 - Overrun on channel A");
878 break;
879 case 0x01:
880 DEV_MESSAGE(KERN_WARNING, device, "%s",
881 "FORMAT 6 - Overrun on channel B");
882 break;
883 case 0x02:
884 DEV_MESSAGE(KERN_WARNING, device, "%s",
885 "FORMAT 6 - Overrun on channel C");
886 break;
887 case 0x03:
888 DEV_MESSAGE(KERN_WARNING, device, "%s",
889 "FORMAT 6 - Overrun on channel D");
890 break;
891 case 0x04:
892 DEV_MESSAGE(KERN_WARNING, device, "%s",
893 "FORMAT 6 - Overrun on channel E");
894 break;
895 case 0x05:
896 DEV_MESSAGE(KERN_WARNING, device, "%s",
897 "FORMAT 6 - Overrun on channel F");
898 break;
899 case 0x06:
900 DEV_MESSAGE(KERN_WARNING, device, "%s",
901 "FORMAT 6 - Overrun on channel G");
902 break;
903 case 0x07:
904 DEV_MESSAGE(KERN_WARNING, device, "%s",
905 "FORMAT 6 - Overrun on channel H");
906 break;
907 default:
908 DEV_MESSAGE(KERN_WARNING, device, "%s",
909 "FORMAT 6 - Reserved");
910 }
911 break;
912
913 case 0x70: /* Format 7 - Device Connection Control Checks */
914 switch (msg_no) {
915 case 0x00:
916 DEV_MESSAGE(KERN_WARNING, device, "%s",
917 "FORMAT 7 - RCC initiated by a connection "
918 "check alert");
919 break;
920 case 0x01:
921 DEV_MESSAGE(KERN_WARNING, device, "%s",
922 "FORMAT 7 - RCC 1 sequence not "
923 "successful");
924 break;
925 case 0x02:
926 DEV_MESSAGE(KERN_WARNING, device, "%s",
927 "FORMAT 7 - RCC 1 and RCC 2 sequences not "
928 "successful");
929 break;
930 case 0x03:
931 DEV_MESSAGE(KERN_WARNING, device, "%s",
932 "FORMAT 7 - Invalid tag-in during "
933 "selection sequence");
934 break;
935 case 0x04:
936 DEV_MESSAGE(KERN_WARNING, device, "%s",
937 "FORMAT 7 - extra RCC required");
938 break;
939 case 0x05:
940 DEV_MESSAGE(KERN_WARNING, device, "%s",
941 "FORMAT 7 - Invalid DCC selection "
942 "response or timeout");
943 break;
944 case 0x06:
945 DEV_MESSAGE(KERN_WARNING, device, "%s",
946 "FORMAT 7 - Missing end operation; device "
947 "transfer complete");
948 break;
949 case 0x07:
950 DEV_MESSAGE(KERN_WARNING, device, "%s",
951 "FORMAT 7 - Missing end operation; device "
952 "transfer incomplete");
953 break;
954 case 0x08:
955 DEV_MESSAGE(KERN_WARNING, device, "%s",
956 "FORMAT 7 - Invalid tag-in for an "
957 "immediate command sequence");
958 break;
959 case 0x09:
960 DEV_MESSAGE(KERN_WARNING, device, "%s",
961 "FORMAT 7 - Invalid tag-in for an "
962 "extended command sequence");
963 break;
964 case 0x0A:
965 DEV_MESSAGE(KERN_WARNING, device, "%s",
966 "FORMAT 7 - 3990 microcode time out when "
967 "stopping selection");
968 break;
969 case 0x0B:
970 DEV_MESSAGE(KERN_WARNING, device, "%s",
971 "FORMAT 7 - No response to selection "
972 "after a poll interruption");
973 break;
974 case 0x0C:
975 DEV_MESSAGE(KERN_WARNING, device, "%s",
976 "FORMAT 7 - Permanent path error (DASD "
977 "controller not available)");
978 break;
979 case 0x0D:
980 DEV_MESSAGE(KERN_WARNING, device, "%s",
981 "FORMAT 7 - DASD controller not available"
982 " on disconnected command chain");
983 break;
984 default:
985 DEV_MESSAGE(KERN_WARNING, device, "%s",
986 "FORMAT 7 - Reserved");
987 }
988 break;
989
990 case 0x80: /* Format 8 - Additional Device Equipment Checks */
991 switch (msg_no) {
992 case 0x00: /* No Message */
993 case 0x01:
994 DEV_MESSAGE(KERN_WARNING, device, "%s",
995 "FORMAT 8 - Error correction code "
996 "hardware fault");
997 break;
998 case 0x03:
999 DEV_MESSAGE(KERN_WARNING, device, "%s",
1000 "FORMAT 8 - Unexpected end operation "
1001 "response code");
1002 break;
1003 case 0x04:
1004 DEV_MESSAGE(KERN_WARNING, device, "%s",
1005 "FORMAT 8 - End operation with transfer "
1006 "count not zero");
1007 break;
1008 case 0x05:
1009 DEV_MESSAGE(KERN_WARNING, device, "%s",
1010 "FORMAT 8 - End operation with transfer "
1011 "count zero");
1012 break;
1013 case 0x06:
1014 DEV_MESSAGE(KERN_WARNING, device, "%s",
1015 "FORMAT 8 - DPS checks after a system "
1016 "reset or selective reset");
1017 break;
1018 case 0x07:
1019 DEV_MESSAGE(KERN_WARNING, device, "%s",
1020 "FORMAT 8 - DPS cannot be filled");
1021 break;
1022 case 0x08:
1023 DEV_MESSAGE(KERN_WARNING, device, "%s",
1024 "FORMAT 8 - Short busy time-out during "
1025 "device selection");
1026 break;
1027 case 0x09:
1028 DEV_MESSAGE(KERN_WARNING, device, "%s",
1029 "FORMAT 8 - DASD controller failed to "
1030 "set or reset the long busy latch");
1031 break;
1032 case 0x0A:
1033 DEV_MESSAGE(KERN_WARNING, device, "%s",
1034 "FORMAT 8 - No interruption from device "
1035 "during a command chain");
1036 break;
1037 default:
1038 DEV_MESSAGE(KERN_WARNING, device, "%s",
1039 "FORMAT 8 - Reserved");
1040 }
1041 break;
1042
1043 case 0x90: /* Format 9 - Device Read, Write, and Seek Checks */
1044 switch (msg_no) {
1045 case 0x00:
1046 break; /* No Message */
1047 case 0x06:
1048 DEV_MESSAGE(KERN_WARNING, device, "%s",
1049 "FORMAT 9 - Device check-2 error");
1050 break;
1051 case 0x07:
1052 DEV_MESSAGE(KERN_WARNING, device, "%s",
1053 "FORMAT 9 - Head address did not compare");
1054 break;
1055 case 0x0A:
1056 DEV_MESSAGE(KERN_WARNING, device, "%s",
1057 "FORMAT 9 - Track physical address did "
1058 "not compare while oriented");
1059 break;
1060 case 0x0E:
1061 DEV_MESSAGE(KERN_WARNING, device, "%s",
1062 "FORMAT 9 - Cylinder address did not "
1063 "compare");
1064 break;
1065 default:
1066 DEV_MESSAGE(KERN_WARNING, device, "%s",
1067 "FORMAT 9 - Reserved");
1068 }
1069 break;
1070
1071 case 0xF0: /* Format F - Cache Storage Checks */
1072 switch (msg_no) {
1073 case 0x00:
1074 DEV_MESSAGE(KERN_WARNING, device, "%s",
1075 "FORMAT F - Operation Terminated");
1076 break;
1077 case 0x01:
1078 DEV_MESSAGE(KERN_WARNING, device, "%s",
1079 "FORMAT F - Subsystem Processing Error");
1080 break;
1081 case 0x02:
1082 DEV_MESSAGE(KERN_WARNING, device, "%s",
1083 "FORMAT F - Cache or nonvolatile storage "
1084 "equipment failure");
1085 break;
1086 case 0x04:
1087 DEV_MESSAGE(KERN_WARNING, device, "%s",
1088 "FORMAT F - Caching terminated");
1089 break;
1090 case 0x06:
1091 DEV_MESSAGE(KERN_WARNING, device, "%s",
1092 "FORMAT F - Cache fast write access not "
1093 "authorized");
1094 break;
1095 case 0x07:
1096 DEV_MESSAGE(KERN_WARNING, device, "%s",
1097 "FORMAT F - Track format incorrect");
1098 break;
1099 case 0x09:
1100 DEV_MESSAGE(KERN_WARNING, device, "%s",
1101 "FORMAT F - Caching reinitiated");
1102 break;
1103 case 0x0A:
1104 DEV_MESSAGE(KERN_WARNING, device, "%s",
1105 "FORMAT F - Nonvolatile storage "
1106 "terminated");
1107 break;
1108 case 0x0B:
1109 DEV_MESSAGE(KERN_WARNING, device, "%s",
1110 "FORMAT F - Volume is suspended duplex");
1111 break;
1112 case 0x0C:
1113 DEV_MESSAGE(KERN_WARNING, device, "%s",
1114 "FORMAT F - Subsystem status connot be "
1115 "determined");
1116 break;
1117 case 0x0D:
1118 DEV_MESSAGE(KERN_WARNING, device, "%s",
1119 "FORMAT F - Caching status reset to "
1120 "default");
1121 break;
1122 case 0x0E:
1123 DEV_MESSAGE(KERN_WARNING, device, "%s",
1124 "FORMAT F - DASD Fast Write inhibited");
1125 break;
1126 default:
1127 DEV_MESSAGE(KERN_WARNING, device, "%s",
1128 "FORMAT D - Reserved");
1129 }
1130 break;
1131
1132 default: /* unknown message format - should not happen */
1133 DEV_MESSAGE (KERN_WARNING, device,
1134 "unknown message format %02x",
1135 msg_format);
1136 break;
1137 } /* end switch message format */
1138
1139 } /* end dasd_3990_handle_env_data */
1140
1141 /*
1142 * DASD_3990_ERP_COM_REJ
1143 *
1144 * DESCRIPTION
1145 * Handles 24 byte 'Command Reject' error.
1146 *
1147 * PARAMETER
1148 * erp current erp_head
1149 * sense current sense data
1150 *
1151 * RETURN VALUES
1152 * erp 'new' erp_head - pointer to new ERP
1153 */
1154 static struct dasd_ccw_req *
1155 dasd_3990_erp_com_rej(struct dasd_ccw_req * erp, char *sense)
1156 {
1157
1158 struct dasd_device *device = erp->device;
1159
1160 erp->function = dasd_3990_erp_com_rej;
1161
1162 /* env data present (ACTION 10 - retry should work) */
1163 if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1164
1165 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1166 "Command Reject - environmental data present");
1167
1168 dasd_3990_handle_env_data(erp, sense);
1169
1170 erp->retries = 5;
1171
1172 } else {
1173 /* fatal error - set status to FAILED */
1174 DEV_MESSAGE(KERN_ERR, device, "%s",
1175 "Command Reject - Fatal error");
1176
1177 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1178 }
1179
1180 return erp;
1181
1182 } /* end dasd_3990_erp_com_rej */
1183
1184 /*
1185 * DASD_3990_ERP_BUS_OUT
1186 *
1187 * DESCRIPTION
1188 * Handles 24 byte 'Bus Out Parity Check' error.
1189 *
1190 * PARAMETER
1191 * erp current erp_head
1192 * RETURN VALUES
1193 * erp new erp_head - pointer to new ERP
1194 */
1195 static struct dasd_ccw_req *
1196 dasd_3990_erp_bus_out(struct dasd_ccw_req * erp)
1197 {
1198
1199 struct dasd_device *device = erp->device;
1200
1201 /* first time set initial retry counter and erp_function */
1202 /* and retry once without blocking queue */
1203 /* (this enables easier enqueing of the cqr) */
1204 if (erp->function != dasd_3990_erp_bus_out) {
1205 erp->retries = 256;
1206 erp->function = dasd_3990_erp_bus_out;
1207
1208 } else {
1209
1210 /* issue a message and wait for 'device ready' interrupt */
1211 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1212 "bus out parity error or BOPC requested by "
1213 "channel");
1214
1215 dasd_3990_erp_block_queue(erp, 60*HZ);
1216
1217 }
1218
1219 return erp;
1220
1221 } /* end dasd_3990_erp_bus_out */
1222
1223 /*
1224 * DASD_3990_ERP_EQUIP_CHECK
1225 *
1226 * DESCRIPTION
1227 * Handles 24 byte 'Equipment Check' error.
1228 *
1229 * PARAMETER
1230 * erp current erp_head
1231 * RETURN VALUES
1232 * erp new erp_head - pointer to new ERP
1233 */
1234 static struct dasd_ccw_req *
1235 dasd_3990_erp_equip_check(struct dasd_ccw_req * erp, char *sense)
1236 {
1237
1238 struct dasd_device *device = erp->device;
1239
1240 erp->function = dasd_3990_erp_equip_check;
1241
1242 if (sense[1] & SNS1_WRITE_INHIBITED) {
1243
1244 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1245 "Write inhibited path encountered");
1246
1247 /* vary path offline */
1248 DEV_MESSAGE(KERN_ERR, device, "%s",
1249 "Path should be varied off-line. "
1250 "This is not implemented yet \n - please report "
1251 "to linux390@de.ibm.com");
1252
1253 erp = dasd_3990_erp_action_1(erp);
1254
1255 } else if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1256
1257 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1258 "Equipment Check - " "environmental data present");
1259
1260 dasd_3990_handle_env_data(erp, sense);
1261
1262 erp = dasd_3990_erp_action_4(erp, sense);
1263
1264 } else if (sense[1] & SNS1_PERM_ERR) {
1265
1266 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1267 "Equipment Check - retry exhausted or "
1268 "undesirable");
1269
1270 erp = dasd_3990_erp_action_1(erp);
1271
1272 } else {
1273 /* all other equipment checks - Action 5 */
1274 /* rest is done when retries == 0 */
1275 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1276 "Equipment check or processing error");
1277
1278 erp = dasd_3990_erp_action_5(erp);
1279 }
1280
1281 return erp;
1282
1283 } /* end dasd_3990_erp_equip_check */
1284
1285 /*
1286 * DASD_3990_ERP_DATA_CHECK
1287 *
1288 * DESCRIPTION
1289 * Handles 24 byte 'Data Check' error.
1290 *
1291 * PARAMETER
1292 * erp current erp_head
1293 * RETURN VALUES
1294 * erp new erp_head - pointer to new ERP
1295 */
1296 static struct dasd_ccw_req *
1297 dasd_3990_erp_data_check(struct dasd_ccw_req * erp, char *sense)
1298 {
1299
1300 struct dasd_device *device = erp->device;
1301
1302 erp->function = dasd_3990_erp_data_check;
1303
1304 if (sense[2] & SNS2_CORRECTABLE) { /* correctable data check */
1305
1306 /* issue message that the data has been corrected */
1307 DEV_MESSAGE(KERN_EMERG, device, "%s",
1308 "Data recovered during retry with PCI "
1309 "fetch mode active");
1310
1311 /* not possible to handle this situation in Linux */
1312 panic("No way to inform application about the possibly "
1313 "incorrect data");
1314
1315 } else if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1316
1317 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1318 "Uncorrectable data check recovered secondary "
1319 "addr of duplex pair");
1320
1321 erp = dasd_3990_erp_action_4(erp, sense);
1322
1323 } else if (sense[1] & SNS1_PERM_ERR) {
1324
1325 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1326 "Uncorrectable data check with internal "
1327 "retry exhausted");
1328
1329 erp = dasd_3990_erp_action_1(erp);
1330
1331 } else {
1332 /* all other data checks */
1333 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1334 "Uncorrectable data check with retry count "
1335 "exhausted...");
1336
1337 erp = dasd_3990_erp_action_5(erp);
1338 }
1339
1340 return erp;
1341
1342 } /* end dasd_3990_erp_data_check */
1343
1344 /*
1345 * DASD_3990_ERP_OVERRUN
1346 *
1347 * DESCRIPTION
1348 * Handles 24 byte 'Overrun' error.
1349 *
1350 * PARAMETER
1351 * erp current erp_head
1352 * RETURN VALUES
1353 * erp new erp_head - pointer to new ERP
1354 */
1355 static struct dasd_ccw_req *
1356 dasd_3990_erp_overrun(struct dasd_ccw_req * erp, char *sense)
1357 {
1358
1359 struct dasd_device *device = erp->device;
1360
1361 erp->function = dasd_3990_erp_overrun;
1362
1363 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1364 "Overrun - service overrun or overrun"
1365 " error requested by channel");
1366
1367 erp = dasd_3990_erp_action_5(erp);
1368
1369 return erp;
1370
1371 } /* end dasd_3990_erp_overrun */
1372
1373 /*
1374 * DASD_3990_ERP_INV_FORMAT
1375 *
1376 * DESCRIPTION
1377 * Handles 24 byte 'Invalid Track Format' error.
1378 *
1379 * PARAMETER
1380 * erp current erp_head
1381 * RETURN VALUES
1382 * erp new erp_head - pointer to new ERP
1383 */
1384 static struct dasd_ccw_req *
1385 dasd_3990_erp_inv_format(struct dasd_ccw_req * erp, char *sense)
1386 {
1387
1388 struct dasd_device *device = erp->device;
1389
1390 erp->function = dasd_3990_erp_inv_format;
1391
1392 if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1393
1394 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1395 "Track format error when destaging or "
1396 "staging data");
1397
1398 dasd_3990_handle_env_data(erp, sense);
1399
1400 erp = dasd_3990_erp_action_4(erp, sense);
1401
1402 } else {
1403 DEV_MESSAGE(KERN_ERR, device, "%s",
1404 "Invalid Track Format - Fatal error should have "
1405 "been handled within the interrupt handler");
1406
1407 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1408 }
1409
1410 return erp;
1411
1412 } /* end dasd_3990_erp_inv_format */
1413
1414 /*
1415 * DASD_3990_ERP_EOC
1416 *
1417 * DESCRIPTION
1418 * Handles 24 byte 'End-of-Cylinder' error.
1419 *
1420 * PARAMETER
1421 * erp already added default erp
1422 * RETURN VALUES
1423 * erp pointer to original (failed) cqr.
1424 */
1425 static struct dasd_ccw_req *
1426 dasd_3990_erp_EOC(struct dasd_ccw_req * default_erp, char *sense)
1427 {
1428
1429 struct dasd_device *device = default_erp->device;
1430
1431 DEV_MESSAGE(KERN_ERR, device, "%s",
1432 "End-of-Cylinder - must never happen");
1433
1434 /* implement action 7 - BUG */
1435 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1436
1437 } /* end dasd_3990_erp_EOC */
1438
1439 /*
1440 * DASD_3990_ERP_ENV_DATA
1441 *
1442 * DESCRIPTION
1443 * Handles 24 byte 'Environmental-Data Present' error.
1444 *
1445 * PARAMETER
1446 * erp current erp_head
1447 * RETURN VALUES
1448 * erp new erp_head - pointer to new ERP
1449 */
1450 static struct dasd_ccw_req *
1451 dasd_3990_erp_env_data(struct dasd_ccw_req * erp, char *sense)
1452 {
1453
1454 struct dasd_device *device = erp->device;
1455
1456 erp->function = dasd_3990_erp_env_data;
1457
1458 DEV_MESSAGE(KERN_DEBUG, device, "%s", "Environmental data present");
1459
1460 dasd_3990_handle_env_data(erp, sense);
1461
1462 /* don't retry on disabled interface */
1463 if (sense[7] != 0x0F) {
1464
1465 erp = dasd_3990_erp_action_4(erp, sense);
1466 } else {
1467
1468 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_IN_IO);
1469 }
1470
1471 return erp;
1472
1473 } /* end dasd_3990_erp_env_data */
1474
1475 /*
1476 * DASD_3990_ERP_NO_REC
1477 *
1478 * DESCRIPTION
1479 * Handles 24 byte 'No Record Found' error.
1480 *
1481 * PARAMETER
1482 * erp already added default ERP
1483 *
1484 * RETURN VALUES
1485 * erp new erp_head - pointer to new ERP
1486 */
1487 static struct dasd_ccw_req *
1488 dasd_3990_erp_no_rec(struct dasd_ccw_req * default_erp, char *sense)
1489 {
1490
1491 struct dasd_device *device = default_erp->device;
1492
1493 DEV_MESSAGE(KERN_ERR, device, "%s",
1494 "No Record Found - Fatal error should "
1495 "have been handled within the interrupt handler");
1496
1497 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1498
1499 } /* end dasd_3990_erp_no_rec */
1500
1501 /*
1502 * DASD_3990_ERP_FILE_PROT
1503 *
1504 * DESCRIPTION
1505 * Handles 24 byte 'File Protected' error.
1506 * Note: Seek related recovery is not implemented because
1507 * wee don't use the seek command yet.
1508 *
1509 * PARAMETER
1510 * erp current erp_head
1511 * RETURN VALUES
1512 * erp new erp_head - pointer to new ERP
1513 */
1514 static struct dasd_ccw_req *
1515 dasd_3990_erp_file_prot(struct dasd_ccw_req * erp)
1516 {
1517
1518 struct dasd_device *device = erp->device;
1519
1520 DEV_MESSAGE(KERN_ERR, device, "%s", "File Protected");
1521
1522 return dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1523
1524 } /* end dasd_3990_erp_file_prot */
1525
1526 /*
1527 * DASD_3990_ERP_INSPECT_24
1528 *
1529 * DESCRIPTION
1530 * Does a detailed inspection of the 24 byte sense data
1531 * and sets up a related error recovery action.
1532 *
1533 * PARAMETER
1534 * sense sense data of the actual error
1535 * erp pointer to the currently created default ERP
1536 *
1537 * RETURN VALUES
1538 * erp pointer to the (addtitional) ERP
1539 */
1540 static struct dasd_ccw_req *
1541 dasd_3990_erp_inspect_24(struct dasd_ccw_req * erp, char *sense)
1542 {
1543
1544 struct dasd_ccw_req *erp_filled = NULL;
1545
1546 /* Check sense for .... */
1547 /* 'Command Reject' */
1548 if ((erp_filled == NULL) && (sense[0] & SNS0_CMD_REJECT)) {
1549 erp_filled = dasd_3990_erp_com_rej(erp, sense);
1550 }
1551 /* 'Intervention Required' */
1552 if ((erp_filled == NULL) && (sense[0] & SNS0_INTERVENTION_REQ)) {
1553 erp_filled = dasd_3990_erp_int_req(erp);
1554 }
1555 /* 'Bus Out Parity Check' */
1556 if ((erp_filled == NULL) && (sense[0] & SNS0_BUS_OUT_CHECK)) {
1557 erp_filled = dasd_3990_erp_bus_out(erp);
1558 }
1559 /* 'Equipment Check' */
1560 if ((erp_filled == NULL) && (sense[0] & SNS0_EQUIPMENT_CHECK)) {
1561 erp_filled = dasd_3990_erp_equip_check(erp, sense);
1562 }
1563 /* 'Data Check' */
1564 if ((erp_filled == NULL) && (sense[0] & SNS0_DATA_CHECK)) {
1565 erp_filled = dasd_3990_erp_data_check(erp, sense);
1566 }
1567 /* 'Overrun' */
1568 if ((erp_filled == NULL) && (sense[0] & SNS0_OVERRUN)) {
1569 erp_filled = dasd_3990_erp_overrun(erp, sense);
1570 }
1571 /* 'Invalid Track Format' */
1572 if ((erp_filled == NULL) && (sense[1] & SNS1_INV_TRACK_FORMAT)) {
1573 erp_filled = dasd_3990_erp_inv_format(erp, sense);
1574 }
1575 /* 'End-of-Cylinder' */
1576 if ((erp_filled == NULL) && (sense[1] & SNS1_EOC)) {
1577 erp_filled = dasd_3990_erp_EOC(erp, sense);
1578 }
1579 /* 'Environmental Data' */
1580 if ((erp_filled == NULL) && (sense[2] & SNS2_ENV_DATA_PRESENT)) {
1581 erp_filled = dasd_3990_erp_env_data(erp, sense);
1582 }
1583 /* 'No Record Found' */
1584 if ((erp_filled == NULL) && (sense[1] & SNS1_NO_REC_FOUND)) {
1585 erp_filled = dasd_3990_erp_no_rec(erp, sense);
1586 }
1587 /* 'File Protected' */
1588 if ((erp_filled == NULL) && (sense[1] & SNS1_FILE_PROTECTED)) {
1589 erp_filled = dasd_3990_erp_file_prot(erp);
1590 }
1591 /* other (unknown) error - do default ERP */
1592 if (erp_filled == NULL) {
1593
1594 erp_filled = erp;
1595 }
1596
1597 return erp_filled;
1598
1599 } /* END dasd_3990_erp_inspect_24 */
1600
1601 /*
1602 *****************************************************************************
1603 * 32 byte sense ERP functions (only)
1604 *****************************************************************************
1605 */
1606
1607 /*
1608 * DASD_3990_ERPACTION_10_32
1609 *
1610 * DESCRIPTION
1611 * Handles 32 byte 'Action 10' of Single Program Action Codes.
1612 * Just retry and if retry doesn't work, return with error.
1613 *
1614 * PARAMETER
1615 * erp current erp_head
1616 * sense current sense data
1617 * RETURN VALUES
1618 * erp modified erp_head
1619 */
1620 static struct dasd_ccw_req *
1621 dasd_3990_erp_action_10_32(struct dasd_ccw_req * erp, char *sense)
1622 {
1623
1624 struct dasd_device *device = erp->device;
1625
1626 erp->retries = 256;
1627 erp->function = dasd_3990_erp_action_10_32;
1628
1629 DEV_MESSAGE(KERN_DEBUG, device, "%s", "Perform logging requested");
1630
1631 return erp;
1632
1633 } /* end dasd_3990_erp_action_10_32 */
1634
1635 /*
1636 * DASD_3990_ERP_ACTION_1B_32
1637 *
1638 * DESCRIPTION
1639 * Handles 32 byte 'Action 1B' of Single Program Action Codes.
1640 * A write operation could not be finished because of an unexpected
1641 * condition.
1642 * The already created 'default erp' is used to get the link to
1643 * the erp chain, but it can not be used for this recovery
1644 * action because it contains no DE/LO data space.
1645 *
1646 * PARAMETER
1647 * default_erp already added default erp.
1648 * sense current sense data
1649 *
1650 * RETURN VALUES
1651 * erp new erp or
1652 * default_erp in case of imprecise ending or error
1653 */
1654 static struct dasd_ccw_req *
1655 dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
1656 {
1657
1658 struct dasd_device *device = default_erp->device;
1659 __u32 cpa = 0;
1660 struct dasd_ccw_req *cqr;
1661 struct dasd_ccw_req *erp;
1662 struct DE_eckd_data *DE_data;
1663 char *LO_data; /* LO_eckd_data_t */
1664 struct ccw1 *ccw;
1665
1666 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1667 "Write not finished because of unexpected condition");
1668
1669 default_erp->function = dasd_3990_erp_action_1B_32;
1670
1671 /* determine the original cqr */
1672 cqr = default_erp;
1673
1674 while (cqr->refers != NULL) {
1675 cqr = cqr->refers;
1676 }
1677
1678 /* for imprecise ending just do default erp */
1679 if (sense[1] & 0x01) {
1680
1681 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1682 "Imprecise ending is set - just retry");
1683
1684 return default_erp;
1685 }
1686
1687 /* determine the address of the CCW to be restarted */
1688 /* Imprecise ending is not set -> addr from IRB-SCSW */
1689 cpa = default_erp->refers->irb.scsw.cpa;
1690
1691 if (cpa == 0) {
1692
1693 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1694 "Unable to determine address of the CCW "
1695 "to be restarted");
1696
1697 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1698 }
1699
1700 /* Build new ERP request including DE/LO */
1701 erp = dasd_alloc_erp_request((char *) &cqr->magic,
1702 2 + 1,/* DE/LO + TIC */
1703 sizeof (struct DE_eckd_data) +
1704 sizeof (struct LO_eckd_data), device);
1705
1706 if (IS_ERR(erp)) {
1707 DEV_MESSAGE(KERN_ERR, device, "%s", "Unable to allocate ERP");
1708 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1709 }
1710
1711 /* use original DE */
1712 DE_data = erp->data;
1713 memcpy(DE_data, cqr->data, sizeof (struct DE_eckd_data));
1714
1715 /* create LO */
1716 LO_data = erp->data + sizeof (struct DE_eckd_data);
1717
1718 if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
1719
1720 DEV_MESSAGE(KERN_ERR, device, "%s",
1721 "BUG - this should not happen");
1722
1723 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1724 }
1725
1726 if ((sense[7] & 0x3F) == 0x01) {
1727 /* operation code is WRITE DATA -> data area orientation */
1728 LO_data[0] = 0x81;
1729
1730 } else if ((sense[7] & 0x3F) == 0x03) {
1731 /* operation code is FORMAT WRITE -> index orientation */
1732 LO_data[0] = 0xC3;
1733
1734 } else {
1735 LO_data[0] = sense[7]; /* operation */
1736 }
1737
1738 LO_data[1] = sense[8]; /* auxiliary */
1739 LO_data[2] = sense[9];
1740 LO_data[3] = sense[3]; /* count */
1741 LO_data[4] = sense[29]; /* seek_addr.cyl */
1742 LO_data[5] = sense[30]; /* seek_addr.cyl 2nd byte */
1743 LO_data[7] = sense[31]; /* seek_addr.head 2nd byte */
1744
1745 memcpy(&(LO_data[8]), &(sense[11]), 8);
1746
1747 /* create DE ccw */
1748 ccw = erp->cpaddr;
1749 memset(ccw, 0, sizeof (struct ccw1));
1750 ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT;
1751 ccw->flags = CCW_FLAG_CC;
1752 ccw->count = 16;
1753 ccw->cda = (__u32)(addr_t) DE_data;
1754
1755 /* create LO ccw */
1756 ccw++;
1757 memset(ccw, 0, sizeof (struct ccw1));
1758 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD;
1759 ccw->flags = CCW_FLAG_CC;
1760 ccw->count = 16;
1761 ccw->cda = (__u32)(addr_t) LO_data;
1762
1763 /* TIC to the failed ccw */
1764 ccw++;
1765 ccw->cmd_code = CCW_CMD_TIC;
1766 ccw->cda = cpa;
1767
1768 /* fill erp related fields */
1769 erp->function = dasd_3990_erp_action_1B_32;
1770 erp->refers = default_erp->refers;
1771 erp->device = device;
1772 erp->magic = default_erp->magic;
1773 erp->expires = 0;
1774 erp->retries = 256;
1775 erp->buildclk = get_clock();
1776 erp->status = DASD_CQR_FILLED;
1777
1778 /* remove the default erp */
1779 dasd_free_erp_request(default_erp, device);
1780
1781 return erp;
1782
1783 } /* end dasd_3990_erp_action_1B_32 */
1784
1785 /*
1786 * DASD_3990_UPDATE_1B
1787 *
1788 * DESCRIPTION
1789 * Handles the update to the 32 byte 'Action 1B' of Single Program
1790 * Action Codes in case the first action was not successful.
1791 * The already created 'previous_erp' is the currently not successful
1792 * ERP.
1793 *
1794 * PARAMETER
1795 * previous_erp already created previous erp.
1796 * sense current sense data
1797 * RETURN VALUES
1798 * erp modified erp
1799 */
1800 static struct dasd_ccw_req *
1801 dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense)
1802 {
1803
1804 struct dasd_device *device = previous_erp->device;
1805 __u32 cpa = 0;
1806 struct dasd_ccw_req *cqr;
1807 struct dasd_ccw_req *erp;
1808 char *LO_data; /* struct LO_eckd_data */
1809 struct ccw1 *ccw;
1810
1811 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1812 "Write not finished because of unexpected condition"
1813 " - follow on");
1814
1815 /* determine the original cqr */
1816 cqr = previous_erp;
1817
1818 while (cqr->refers != NULL) {
1819 cqr = cqr->refers;
1820 }
1821
1822 /* for imprecise ending just do default erp */
1823 if (sense[1] & 0x01) {
1824
1825 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1826 "Imprecise ending is set - just retry");
1827
1828 previous_erp->status = DASD_CQR_QUEUED;
1829
1830 return previous_erp;
1831 }
1832
1833 /* determine the address of the CCW to be restarted */
1834 /* Imprecise ending is not set -> addr from IRB-SCSW */
1835 cpa = previous_erp->irb.scsw.cpa;
1836
1837 if (cpa == 0) {
1838
1839 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1840 "Unable to determine address of the CCW "
1841 "to be restarted");
1842
1843 previous_erp->status = DASD_CQR_FAILED;
1844
1845 return previous_erp;
1846 }
1847
1848 erp = previous_erp;
1849
1850 /* update the LO with the new returned sense data */
1851 LO_data = erp->data + sizeof (struct DE_eckd_data);
1852
1853 if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
1854
1855 DEV_MESSAGE(KERN_ERR, device, "%s",
1856 "BUG - this should not happen");
1857
1858 previous_erp->status = DASD_CQR_FAILED;
1859
1860 return previous_erp;
1861 }
1862
1863 if ((sense[7] & 0x3F) == 0x01) {
1864 /* operation code is WRITE DATA -> data area orientation */
1865 LO_data[0] = 0x81;
1866
1867 } else if ((sense[7] & 0x3F) == 0x03) {
1868 /* operation code is FORMAT WRITE -> index orientation */
1869 LO_data[0] = 0xC3;
1870
1871 } else {
1872 LO_data[0] = sense[7]; /* operation */
1873 }
1874
1875 LO_data[1] = sense[8]; /* auxiliary */
1876 LO_data[2] = sense[9];
1877 LO_data[3] = sense[3]; /* count */
1878 LO_data[4] = sense[29]; /* seek_addr.cyl */
1879 LO_data[5] = sense[30]; /* seek_addr.cyl 2nd byte */
1880 LO_data[7] = sense[31]; /* seek_addr.head 2nd byte */
1881
1882 memcpy(&(LO_data[8]), &(sense[11]), 8);
1883
1884 /* TIC to the failed ccw */
1885 ccw = erp->cpaddr; /* addr of DE ccw */
1886 ccw++; /* addr of LE ccw */
1887 ccw++; /* addr of TIC ccw */
1888 ccw->cda = cpa;
1889
1890 erp->status = DASD_CQR_QUEUED;
1891
1892 return erp;
1893
1894 } /* end dasd_3990_update_1B */
1895
1896 /*
1897 * DASD_3990_ERP_COMPOUND_RETRY
1898 *
1899 * DESCRIPTION
1900 * Handles the compound ERP action retry code.
1901 * NOTE: At least one retry is done even if zero is specified
1902 * by the sense data. This makes enqueueing of the request
1903 * easier.
1904 *
1905 * PARAMETER
1906 * sense sense data of the actual error
1907 * erp pointer to the currently created ERP
1908 *
1909 * RETURN VALUES
1910 * erp modified ERP pointer
1911 *
1912 */
1913 static void
1914 dasd_3990_erp_compound_retry(struct dasd_ccw_req * erp, char *sense)
1915 {
1916
1917 switch (sense[25] & 0x03) {
1918 case 0x00: /* no not retry */
1919 erp->retries = 1;
1920 break;
1921
1922 case 0x01: /* retry 2 times */
1923 erp->retries = 2;
1924 break;
1925
1926 case 0x02: /* retry 10 times */
1927 erp->retries = 10;
1928 break;
1929
1930 case 0x03: /* retry 256 times */
1931 erp->retries = 256;
1932 break;
1933
1934 default:
1935 BUG();
1936 }
1937
1938 erp->function = dasd_3990_erp_compound_retry;
1939
1940 } /* end dasd_3990_erp_compound_retry */
1941
1942 /*
1943 * DASD_3990_ERP_COMPOUND_PATH
1944 *
1945 * DESCRIPTION
1946 * Handles the compound ERP action for retry on alternate
1947 * channel path.
1948 *
1949 * PARAMETER
1950 * sense sense data of the actual error
1951 * erp pointer to the currently created ERP
1952 *
1953 * RETURN VALUES
1954 * erp modified ERP pointer
1955 *
1956 */
1957 static void
1958 dasd_3990_erp_compound_path(struct dasd_ccw_req * erp, char *sense)
1959 {
1960
1961 if (sense[25] & DASD_SENSE_BIT_3) {
1962 dasd_3990_erp_alternate_path(erp);
1963
1964 if (erp->status == DASD_CQR_FAILED) {
1965 /* reset the lpm and the status to be able to
1966 * try further actions. */
1967
1968 erp->lpm = 0;
1969
1970 erp->status = DASD_CQR_ERROR;
1971
1972 }
1973 }
1974
1975 erp->function = dasd_3990_erp_compound_path;
1976
1977 } /* end dasd_3990_erp_compound_path */
1978
1979 /*
1980 * DASD_3990_ERP_COMPOUND_CODE
1981 *
1982 * DESCRIPTION
1983 * Handles the compound ERP action for retry code.
1984 *
1985 * PARAMETER
1986 * sense sense data of the actual error
1987 * erp pointer to the currently created ERP
1988 *
1989 * RETURN VALUES
1990 * erp NEW ERP pointer
1991 *
1992 */
1993 static struct dasd_ccw_req *
1994 dasd_3990_erp_compound_code(struct dasd_ccw_req * erp, char *sense)
1995 {
1996
1997 if (sense[25] & DASD_SENSE_BIT_2) {
1998
1999 switch (sense[28]) {
2000 case 0x17:
2001 /* issue a Diagnostic Control command with an
2002 * Inhibit Write subcommand and controler modifier */
2003 erp = dasd_3990_erp_DCTL(erp, 0x20);
2004 break;
2005
2006 case 0x25:
2007 /* wait for 5 seconds and retry again */
2008 erp->retries = 1;
2009
2010 dasd_3990_erp_block_queue (erp, 5*HZ);
2011 break;
2012
2013 default:
2014 /* should not happen - continue */
2015 break;
2016 }
2017 }
2018
2019 erp->function = dasd_3990_erp_compound_code;
2020
2021 return erp;
2022
2023 } /* end dasd_3990_erp_compound_code */
2024
2025 /*
2026 * DASD_3990_ERP_COMPOUND_CONFIG
2027 *
2028 * DESCRIPTION
2029 * Handles the compound ERP action for configruation
2030 * dependent error.
2031 * Note: duplex handling is not implemented (yet).
2032 *
2033 * PARAMETER
2034 * sense sense data of the actual error
2035 * erp pointer to the currently created ERP
2036 *
2037 * RETURN VALUES
2038 * erp modified ERP pointer
2039 *
2040 */
2041 static void
2042 dasd_3990_erp_compound_config(struct dasd_ccw_req * erp, char *sense)
2043 {
2044
2045 if ((sense[25] & DASD_SENSE_BIT_1) && (sense[26] & DASD_SENSE_BIT_2)) {
2046
2047 /* set to suspended duplex state then restart */
2048 struct dasd_device *device = erp->device;
2049
2050 DEV_MESSAGE(KERN_ERR, device, "%s",
2051 "Set device to suspended duplex state should be "
2052 "done!\n"
2053 "This is not implemented yet (for compound ERP)"
2054 " - please report to linux390@de.ibm.com");
2055
2056 }
2057
2058 erp->function = dasd_3990_erp_compound_config;
2059
2060 } /* end dasd_3990_erp_compound_config */
2061
2062 /*
2063 * DASD_3990_ERP_COMPOUND
2064 *
2065 * DESCRIPTION
2066 * Does the further compound program action if
2067 * compound retry was not successful.
2068 *
2069 * PARAMETER
2070 * sense sense data of the actual error
2071 * erp pointer to the current (failed) ERP
2072 *
2073 * RETURN VALUES
2074 * erp (additional) ERP pointer
2075 *
2076 */
2077 static struct dasd_ccw_req *
2078 dasd_3990_erp_compound(struct dasd_ccw_req * erp, char *sense)
2079 {
2080
2081 if ((erp->function == dasd_3990_erp_compound_retry) &&
2082 (erp->status == DASD_CQR_ERROR)) {
2083
2084 dasd_3990_erp_compound_path(erp, sense);
2085 }
2086
2087 if ((erp->function == dasd_3990_erp_compound_path) &&
2088 (erp->status == DASD_CQR_ERROR)) {
2089
2090 erp = dasd_3990_erp_compound_code(erp, sense);
2091 }
2092
2093 if ((erp->function == dasd_3990_erp_compound_code) &&
2094 (erp->status == DASD_CQR_ERROR)) {
2095
2096 dasd_3990_erp_compound_config(erp, sense);
2097 }
2098
2099 /* if no compound action ERP specified, the request failed */
2100 if (erp->status == DASD_CQR_ERROR) {
2101
2102 erp->status = DASD_CQR_FAILED;
2103 }
2104
2105 return erp;
2106
2107 } /* end dasd_3990_erp_compound */
2108
2109 /*
2110 * DASD_3990_ERP_INSPECT_32
2111 *
2112 * DESCRIPTION
2113 * Does a detailed inspection of the 32 byte sense data
2114 * and sets up a related error recovery action.
2115 *
2116 * PARAMETER
2117 * sense sense data of the actual error
2118 * erp pointer to the currently created default ERP
2119 *
2120 * RETURN VALUES
2121 * erp_filled pointer to the ERP
2122 *
2123 */
2124 static struct dasd_ccw_req *
2125 dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense)
2126 {
2127
2128 struct dasd_device *device = erp->device;
2129
2130 erp->function = dasd_3990_erp_inspect_32;
2131
2132 if (sense[25] & DASD_SENSE_BIT_0) {
2133
2134 /* compound program action codes (byte25 bit 0 == '1') */
2135 dasd_3990_erp_compound_retry(erp, sense);
2136
2137 } else {
2138
2139 /* single program action codes (byte25 bit 0 == '0') */
2140 switch (sense[25]) {
2141
2142 case 0x00: /* success - use default ERP for retries */
2143 DEV_MESSAGE(KERN_DEBUG, device, "%s",
2144 "ERP called for successful request"
2145 " - just retry");
2146 break;
2147
2148 case 0x01: /* fatal error */
2149 DEV_MESSAGE(KERN_ERR, device, "%s",
2150 "Fatal error should have been "
2151 "handled within the interrupt handler");
2152
2153 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2154 break;
2155
2156 case 0x02: /* intervention required */
2157 case 0x03: /* intervention required during dual copy */
2158 erp = dasd_3990_erp_int_req(erp);
2159 break;
2160
2161 case 0x0F: /* length mismatch during update write command */
2162 DEV_MESSAGE(KERN_ERR, device, "%s",
2163 "update write command error - should not "
2164 "happen;\n"
2165 "Please send this message together with "
2166 "the above sense data to linux390@de."
2167 "ibm.com");
2168
2169 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2170 break;
2171
2172 case 0x10: /* logging required for other channel program */
2173 erp = dasd_3990_erp_action_10_32(erp, sense);
2174 break;
2175
2176 case 0x15: /* next track outside defined extend */
2177 DEV_MESSAGE(KERN_ERR, device, "%s",
2178 "next track outside defined extend - "
2179 "should not happen;\n"
2180 "Please send this message together with "
2181 "the above sense data to linux390@de."
2182 "ibm.com");
2183
2184 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2185 break;
2186
2187 case 0x1B: /* unexpected condition during write */
2188
2189 erp = dasd_3990_erp_action_1B_32(erp, sense);
2190 break;
2191
2192 case 0x1C: /* invalid data */
2193 DEV_MESSAGE(KERN_EMERG, device, "%s",
2194 "Data recovered during retry with PCI "
2195 "fetch mode active");
2196
2197 /* not possible to handle this situation in Linux */
2198 panic
2199 ("Invalid data - No way to inform application "
2200 "about the possibly incorrect data");
2201 break;
2202
2203 case 0x1D: /* state-change pending */
2204 DEV_MESSAGE(KERN_DEBUG, device, "%s",
2205 "A State change pending condition exists "
2206 "for the subsystem or device");
2207
2208 erp = dasd_3990_erp_action_4(erp, sense);
2209 break;
2210
2211 case 0x1E: /* busy */
2212 DEV_MESSAGE(KERN_DEBUG, device, "%s",
2213 "Busy condition exists "
2214 "for the subsystem or device");
2215 erp = dasd_3990_erp_action_4(erp, sense);
2216 break;
2217
2218 default: /* all others errors - default erp */
2219 break;
2220 }
2221 }
2222
2223 return erp;
2224
2225 } /* end dasd_3990_erp_inspect_32 */
2226
2227 /*
2228 *****************************************************************************
2229 * main ERP control fuctions (24 and 32 byte sense)
2230 *****************************************************************************
2231 */
2232
2233 /*
2234 * DASD_3990_ERP_INSPECT
2235 *
2236 * DESCRIPTION
2237 * Does a detailed inspection for sense data by calling either
2238 * the 24-byte or the 32-byte inspection routine.
2239 *
2240 * PARAMETER
2241 * erp pointer to the currently created default ERP
2242 * RETURN VALUES
2243 * erp_new contens was possibly modified
2244 */
2245 static struct dasd_ccw_req *
2246 dasd_3990_erp_inspect(struct dasd_ccw_req * erp)
2247 {
2248
2249 struct dasd_ccw_req *erp_new = NULL;
2250 /* sense data are located in the refers record of the */
2251 /* already set up new ERP ! */
2252 char *sense = erp->refers->irb.ecw;
2253
2254 /* distinguish between 24 and 32 byte sense data */
2255 if (sense[27] & DASD_SENSE_BIT_0) {
2256
2257 /* inspect the 24 byte sense data */
2258 erp_new = dasd_3990_erp_inspect_24(erp, sense);
2259
2260 } else {
2261
2262 /* inspect the 32 byte sense data */
2263 erp_new = dasd_3990_erp_inspect_32(erp, sense);
2264
2265 } /* end distinguish between 24 and 32 byte sense data */
2266
2267 return erp_new;
2268 }
2269
2270 /*
2271 * DASD_3990_ERP_ADD_ERP
2272 *
2273 * DESCRIPTION
2274 * This funtion adds an additional request block (ERP) to the head of
2275 * the given cqr (or erp).
2276 * This erp is initialized as an default erp (retry TIC)
2277 *
2278 * PARAMETER
2279 * cqr head of the current ERP-chain (or single cqr if
2280 * first error)
2281 * RETURN VALUES
2282 * erp pointer to new ERP-chain head
2283 */
2284 static struct dasd_ccw_req *
2285 dasd_3990_erp_add_erp(struct dasd_ccw_req * cqr)
2286 {
2287
2288 struct dasd_device *device = cqr->device;
2289 struct ccw1 *ccw;
2290
2291 /* allocate additional request block */
2292 struct dasd_ccw_req *erp;
2293
2294 erp = dasd_alloc_erp_request((char *) &cqr->magic, 2, 0, cqr->device);
2295 if (IS_ERR(erp)) {
2296 if (cqr->retries <= 0) {
2297 DEV_MESSAGE(KERN_ERR, device, "%s",
2298 "Unable to allocate ERP request");
2299 cqr->status = DASD_CQR_FAILED;
2300 cqr->stopclk = get_clock ();
2301 } else {
2302 DEV_MESSAGE (KERN_ERR, device,
2303 "Unable to allocate ERP request "
2304 "(%i retries left)",
2305 cqr->retries);
2306 dasd_set_timer(device, (HZ << 3));
2307 }
2308 return cqr;
2309 }
2310
2311 /* initialize request with default TIC to current ERP/CQR */
2312 ccw = erp->cpaddr;
2313 ccw->cmd_code = CCW_CMD_NOOP;
2314 ccw->flags = CCW_FLAG_CC;
2315 ccw++;
2316 ccw->cmd_code = CCW_CMD_TIC;
2317 ccw->cda = (long)(cqr->cpaddr);
2318 erp->function = dasd_3990_erp_add_erp;
2319 erp->refers = cqr;
2320 erp->device = cqr->device;
2321 erp->magic = cqr->magic;
2322 erp->expires = 0;
2323 erp->retries = 256;
2324 erp->buildclk = get_clock();
2325
2326 erp->status = DASD_CQR_FILLED;
2327
2328 return erp;
2329 }
2330
2331 /*
2332 * DASD_3990_ERP_ADDITIONAL_ERP
2333 *
2334 * DESCRIPTION
2335 * An additional ERP is needed to handle the current error.
2336 * Add ERP to the head of the ERP-chain containing the ERP processing
2337 * determined based on the sense data.
2338 *
2339 * PARAMETER
2340 * cqr head of the current ERP-chain (or single cqr if
2341 * first error)
2342 *
2343 * RETURN VALUES
2344 * erp pointer to new ERP-chain head
2345 */
2346 static struct dasd_ccw_req *
2347 dasd_3990_erp_additional_erp(struct dasd_ccw_req * cqr)
2348 {
2349
2350 struct dasd_ccw_req *erp = NULL;
2351
2352 /* add erp and initialize with default TIC */
2353 erp = dasd_3990_erp_add_erp(cqr);
2354
2355 /* inspect sense, determine specific ERP if possible */
2356 if (erp != cqr) {
2357
2358 erp = dasd_3990_erp_inspect(erp);
2359 }
2360
2361 return erp;
2362
2363 } /* end dasd_3990_erp_additional_erp */
2364
2365 /*
2366 * DASD_3990_ERP_ERROR_MATCH
2367 *
2368 * DESCRIPTION
2369 * Check if the device status of the given cqr is the same.
2370 * This means that the failed CCW and the relevant sense data
2371 * must match.
2372 * I don't distinguish between 24 and 32 byte sense because in case of
2373 * 24 byte sense byte 25 and 27 is set as well.
2374 *
2375 * PARAMETER
2376 * cqr1 first cqr, which will be compared with the
2377 * cqr2 second cqr.
2378 *
2379 * RETURN VALUES
2380 * match 'boolean' for match found
2381 * returns 1 if match found, otherwise 0.
2382 */
2383 static int
2384 dasd_3990_erp_error_match(struct dasd_ccw_req *cqr1, struct dasd_ccw_req *cqr2)
2385 {
2386
2387 /* check failed CCW */
2388 if (cqr1->irb.scsw.cpa != cqr2->irb.scsw.cpa) {
2389 // return 0; /* CCW doesn't match */
2390 }
2391
2392 /* check sense data; byte 0-2,25,27 */
2393 if (!((memcmp (cqr1->irb.ecw, cqr2->irb.ecw, 3) == 0) &&
2394 (cqr1->irb.ecw[27] == cqr2->irb.ecw[27]) &&
2395 (cqr1->irb.ecw[25] == cqr2->irb.ecw[25]))) {
2396
2397 return 0; /* sense doesn't match */
2398 }
2399
2400 return 1; /* match */
2401
2402 } /* end dasd_3990_erp_error_match */
2403
2404 /*
2405 * DASD_3990_ERP_IN_ERP
2406 *
2407 * DESCRIPTION
2408 * check if the current error already happened before.
2409 * quick exit if current cqr is not an ERP (cqr->refers=NULL)
2410 *
2411 * PARAMETER
2412 * cqr failed cqr (either original cqr or already an erp)
2413 *
2414 * RETURN VALUES
2415 * erp erp-pointer to the already defined error
2416 * recovery procedure OR
2417 * NULL if a 'new' error occurred.
2418 */
2419 static struct dasd_ccw_req *
2420 dasd_3990_erp_in_erp(struct dasd_ccw_req *cqr)
2421 {
2422
2423 struct dasd_ccw_req *erp_head = cqr, /* save erp chain head */
2424 *erp_match = NULL; /* save erp chain head */
2425 int match = 0; /* 'boolean' for matching error found */
2426
2427 if (cqr->refers == NULL) { /* return if not in erp */
2428 return NULL;
2429 }
2430
2431 /* check the erp/cqr chain for current error */
2432 do {
2433 match = dasd_3990_erp_error_match(erp_head, cqr->refers);
2434 erp_match = cqr; /* save possible matching erp */
2435 cqr = cqr->refers; /* check next erp/cqr in queue */
2436
2437 } while ((cqr->refers != NULL) && (!match));
2438
2439 if (!match) {
2440 return NULL; /* no match was found */
2441 }
2442
2443 return erp_match; /* return address of matching erp */
2444
2445 } /* END dasd_3990_erp_in_erp */
2446
2447 /*
2448 * DASD_3990_ERP_FURTHER_ERP (24 & 32 byte sense)
2449 *
2450 * DESCRIPTION
2451 * No retry is left for the current ERP. Check what has to be done
2452 * with the ERP.
2453 * - do further defined ERP action or
2454 * - wait for interrupt or
2455 * - exit with permanent error
2456 *
2457 * PARAMETER
2458 * erp ERP which is in progress with no retry left
2459 *
2460 * RETURN VALUES
2461 * erp modified/additional ERP
2462 */
2463 static struct dasd_ccw_req *
2464 dasd_3990_erp_further_erp(struct dasd_ccw_req *erp)
2465 {
2466
2467 struct dasd_device *device = erp->device;
2468 char *sense = erp->irb.ecw;
2469
2470 /* check for 24 byte sense ERP */
2471 if ((erp->function == dasd_3990_erp_bus_out) ||
2472 (erp->function == dasd_3990_erp_action_1) ||
2473 (erp->function == dasd_3990_erp_action_4)) {
2474
2475 erp = dasd_3990_erp_action_1(erp);
2476
2477 } else if (erp->function == dasd_3990_erp_action_5) {
2478
2479 /* retries have not been successful */
2480 /* prepare erp for retry on different channel path */
2481 erp = dasd_3990_erp_action_1(erp);
2482
2483 if (!(sense[2] & DASD_SENSE_BIT_0)) {
2484
2485 /* issue a Diagnostic Control command with an
2486 * Inhibit Write subcommand */
2487
2488 switch (sense[25]) {
2489 case 0x17:
2490 case 0x57:{ /* controller */
2491 erp = dasd_3990_erp_DCTL(erp, 0x20);
2492 break;
2493 }
2494 case 0x18:
2495 case 0x58:{ /* channel path */
2496 erp = dasd_3990_erp_DCTL(erp, 0x40);
2497 break;
2498 }
2499 case 0x19:
2500 case 0x59:{ /* storage director */
2501 erp = dasd_3990_erp_DCTL(erp, 0x80);
2502 break;
2503 }
2504 default:
2505 DEV_MESSAGE(KERN_DEBUG, device,
2506 "invalid subcommand modifier 0x%x "
2507 "for Diagnostic Control Command",
2508 sense[25]);
2509 }
2510 }
2511
2512 /* check for 32 byte sense ERP */
2513 } else if ((erp->function == dasd_3990_erp_compound_retry) ||
2514 (erp->function == dasd_3990_erp_compound_path) ||
2515 (erp->function == dasd_3990_erp_compound_code) ||
2516 (erp->function == dasd_3990_erp_compound_config)) {
2517
2518 erp = dasd_3990_erp_compound(erp, sense);
2519
2520 } else {
2521 /* No retry left and no additional special handling */
2522 /*necessary */
2523 DEV_MESSAGE(KERN_ERR, device,
2524 "no retries left for erp %p - "
2525 "set status to FAILED", erp);
2526
2527 erp->status = DASD_CQR_FAILED;
2528 }
2529
2530 return erp;
2531
2532 } /* end dasd_3990_erp_further_erp */
2533
2534 /*
2535 * DASD_3990_ERP_HANDLE_MATCH_ERP
2536 *
2537 * DESCRIPTION
2538 * An error occurred again and an ERP has been detected which is already
2539 * used to handle this error (e.g. retries).
2540 * All prior ERP's are asumed to be successful and therefore removed
2541 * from queue.
2542 * If retry counter of matching erp is already 0, it is checked if further
2543 * action is needed (besides retry) or if the ERP has failed.
2544 *
2545 * PARAMETER
2546 * erp_head first ERP in ERP-chain
2547 * erp ERP that handles the actual error.
2548 * (matching erp)
2549 *
2550 * RETURN VALUES
2551 * erp modified/additional ERP
2552 */
2553 static struct dasd_ccw_req *
2554 dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head,
2555 struct dasd_ccw_req *erp)
2556 {
2557
2558 struct dasd_device *device = erp_head->device;
2559 struct dasd_ccw_req *erp_done = erp_head; /* finished req */
2560 struct dasd_ccw_req *erp_free = NULL; /* req to be freed */
2561
2562 /* loop over successful ERPs and remove them from chanq */
2563 while (erp_done != erp) {
2564
2565 if (erp_done == NULL) /* end of chain reached */
2566 panic(PRINTK_HEADER "Programming error in ERP! The "
2567 "original request was lost\n");
2568
2569 /* remove the request from the device queue */
2570 list_del(&erp_done->list);
2571
2572 erp_free = erp_done;
2573 erp_done = erp_done->refers;
2574
2575 /* free the finished erp request */
2576 dasd_free_erp_request(erp_free, erp_free->device);
2577
2578 } /* end while */
2579
2580 if (erp->retries > 0) {
2581
2582 char *sense = erp->refers->irb.ecw;
2583
2584 /* check for special retries */
2585 if (erp->function == dasd_3990_erp_action_4) {
2586
2587 erp = dasd_3990_erp_action_4(erp, sense);
2588
2589 } else if (erp->function == dasd_3990_erp_action_1B_32) {
2590
2591 erp = dasd_3990_update_1B(erp, sense);
2592
2593 } else if (erp->function == dasd_3990_erp_int_req) {
2594
2595 erp = dasd_3990_erp_int_req(erp);
2596
2597 } else {
2598 /* simple retry */
2599 DEV_MESSAGE(KERN_DEBUG, device,
2600 "%i retries left for erp %p",
2601 erp->retries, erp);
2602
2603 /* handle the request again... */
2604 erp->status = DASD_CQR_QUEUED;
2605 }
2606
2607 } else {
2608 /* no retry left - check for further necessary action */
2609 /* if no further actions, handle rest as permanent error */
2610 erp = dasd_3990_erp_further_erp(erp);
2611 }
2612
2613 return erp;
2614
2615 } /* end dasd_3990_erp_handle_match_erp */
2616
2617 /*
2618 * DASD_3990_ERP_ACTION
2619 *
2620 * DESCRIPTION
2621 * controll routine for 3990 erp actions.
2622 * Has to be called with the queue lock (namely the s390_irq_lock) acquired.
2623 *
2624 * PARAMETER
2625 * cqr failed cqr (either original cqr or already an erp)
2626 *
2627 * RETURN VALUES
2628 * erp erp-pointer to the head of the ERP action chain.
2629 * This means:
2630 * - either a ptr to an additional ERP cqr or
2631 * - the original given cqr (which's status might
2632 * be modified)
2633 */
2634 struct dasd_ccw_req *
2635 dasd_3990_erp_action(struct dasd_ccw_req * cqr)
2636 {
2637
2638 struct dasd_ccw_req *erp = NULL;
2639 struct dasd_device *device = cqr->device;
2640 __u32 cpa = cqr->irb.scsw.cpa;
2641
2642 #ifdef ERP_DEBUG
2643 /* print current erp_chain */
2644 DEV_MESSAGE(KERN_ERR, device, "%s",
2645 "ERP chain at BEGINNING of ERP-ACTION");
2646 {
2647 struct dasd_ccw_req *temp_erp = NULL;
2648
2649 for (temp_erp = cqr;
2650 temp_erp != NULL; temp_erp = temp_erp->refers) {
2651
2652 DEV_MESSAGE(KERN_ERR, device,
2653 " erp %p (%02x) refers to %p",
2654 temp_erp, temp_erp->status,
2655 temp_erp->refers);
2656 }
2657 }
2658 #endif /* ERP_DEBUG */
2659
2660 /* double-check if current erp/cqr was successfull */
2661 if ((cqr->irb.scsw.cstat == 0x00) &&
2662 (cqr->irb.scsw.dstat == (DEV_STAT_CHN_END|DEV_STAT_DEV_END))) {
2663
2664 DEV_MESSAGE(KERN_DEBUG, device,
2665 "ERP called for successful request %p"
2666 " - NO ERP necessary", cqr);
2667
2668 cqr->status = DASD_CQR_DONE;
2669
2670 return cqr;
2671 }
2672 /* check if sense data are available */
2673 if (!cqr->irb.ecw) {
2674 DEV_MESSAGE(KERN_DEBUG, device,
2675 "ERP called witout sense data avail ..."
2676 "request %p - NO ERP possible", cqr);
2677
2678 cqr->status = DASD_CQR_FAILED;
2679
2680 return cqr;
2681
2682 }
2683
2684 /* check if error happened before */
2685 erp = dasd_3990_erp_in_erp(cqr);
2686
2687 if (erp == NULL) {
2688 /* no matching erp found - set up erp */
2689 erp = dasd_3990_erp_additional_erp(cqr);
2690 } else {
2691 /* matching erp found - set all leading erp's to DONE */
2692 erp = dasd_3990_erp_handle_match_erp(cqr, erp);
2693 }
2694
2695 #ifdef ERP_DEBUG
2696 /* print current erp_chain */
2697 DEV_MESSAGE(KERN_ERR, device, "%s", "ERP chain at END of ERP-ACTION");
2698 {
2699 struct dasd_ccw_req *temp_erp = NULL;
2700 for (temp_erp = erp;
2701 temp_erp != NULL; temp_erp = temp_erp->refers) {
2702
2703 DEV_MESSAGE(KERN_ERR, device,
2704 " erp %p (%02x) refers to %p",
2705 temp_erp, temp_erp->status,
2706 temp_erp->refers);
2707 }
2708 }
2709 #endif /* ERP_DEBUG */
2710
2711 if (erp->status == DASD_CQR_FAILED)
2712 dasd_log_ccw(erp, 1, cpa);
2713
2714 /* enqueue added ERP request */
2715 if (erp->status == DASD_CQR_FILLED) {
2716 erp->status = DASD_CQR_QUEUED;
2717 list_add(&erp->list, &device->ccw_queue);
2718 }
2719
2720 return erp;
2721
2722 } /* end dasd_3990_erp_action */
2723
2724 /*
2725 * Overrides for Emacs so that we follow Linus's tabbing style.
2726 * Emacs will notice this stuff at the end of the file and automatically
2727 * adjust the settings for this buffer only. This must remain at the end
2728 * of the file.
2729 * ---------------------------------------------------------------------------
2730 * Local variables:
2731 * c-indent-level: 4
2732 * c-brace-imaginary-offset: 0
2733 * c-brace-offset: -4
2734 * c-argdecl-indent: 4
2735 * c-label-offset: -4
2736 * c-continued-statement-offset: 4
2737 * c-continued-brace-offset: 0
2738 * indent-tabs-mode: 1
2739 * tab-width: 8
2740 * End:
2741 */
Verdex Pro support