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