License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 08:07:57 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2006-06-29 06:58:12 -06:00
|
|
|
/*
|
|
|
|
* Author(s)......: Horst Hummel <Horst.Hummel@de.ibm.com>
|
2005-04-16 16:20:36 -06:00
|
|
|
* Holger Smolinski <Holger.Smolinski@de.ibm.com>
|
|
|
|
* Bugreports.to..: <Linux390@de.ibm.com>
|
2012-07-20 03:15:04 -06:00
|
|
|
* Copyright IBM Corp. 2000, 2001
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2009-09-11 02:28:30 -06:00
|
|
|
#define KMSG_COMPONENT "dasd-eckd"
|
2009-03-26 08:23:49 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <asm/idals.h>
|
|
|
|
|
|
|
|
#define PRINTK_HEADER "dasd_erp(3990): "
|
|
|
|
|
|
|
|
#include "dasd_int.h"
|
|
|
|
#include "dasd_eckd.h"
|
|
|
|
|
|
|
|
|
|
|
|
struct DCTL_data {
|
|
|
|
unsigned char subcommand; /* e.g Inhibit Write, Enable Write,... */
|
|
|
|
unsigned char modifier; /* Subcommand modifier */
|
|
|
|
unsigned short res; /* reserved */
|
|
|
|
} __attribute__ ((packed));
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
* SECTION ERP HANDLING
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
* 24 and 32 byte sense ERP functions
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_CLEANUP
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Removes the already build but not necessary ERP request and sets
|
|
|
|
* the status of the original cqr / erp to the given (final) status
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp request to be blocked
|
2006-06-29 06:58:12 -06:00
|
|
|
* final_status either DASD_CQR_DONE or DASD_CQR_FAILED
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* RETURN VALUES
|
2006-06-29 06:58:12 -06:00
|
|
|
* cqr original cqr
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_cleanup(struct dasd_ccw_req * erp, char final_status)
|
|
|
|
{
|
|
|
|
struct dasd_ccw_req *cqr = erp->refers;
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
dasd_free_erp_request(erp, erp->memdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
cqr->status = final_status;
|
|
|
|
return cqr;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_cleanup */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_BLOCK_QUEUE
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Block the given device request queue to prevent from further
|
|
|
|
* processing until the started timer has expired or an related
|
|
|
|
* interrupt was received.
|
|
|
|
*/
|
2009-12-07 04:51:51 -07:00
|
|
|
static void dasd_3990_erp_block_queue(struct dasd_ccw_req *erp, int expires)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_INFO, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"blocking request queue for %is", expires/HZ);
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
|
2009-12-07 04:51:51 -07:00
|
|
|
dasd_device_set_stop_bits(device, DASD_STOPPED_PENDING);
|
2008-01-26 06:11:23 -07:00
|
|
|
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
|
|
|
|
erp->status = DASD_CQR_FILLED;
|
2009-12-07 04:51:51 -07:00
|
|
|
if (erp->block)
|
|
|
|
dasd_block_set_timer(erp->block, expires);
|
|
|
|
else
|
|
|
|
dasd_device_set_timer(device, expires);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_INT_REQ
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 'Intervention Required' error.
|
|
|
|
* This means either device offline or not installed.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp modified erp
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_int_req(struct dasd_ccw_req * erp)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* first time set initial retry counter and erp_function */
|
|
|
|
/* and retry once without blocking queue */
|
|
|
|
/* (this enables easier enqueing of the cqr) */
|
|
|
|
if (erp->function != dasd_3990_erp_int_req) {
|
|
|
|
|
|
|
|
erp->retries = 256;
|
|
|
|
erp->function = dasd_3990_erp_int_req;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* issue a message and wait for 'device ready' interrupt */
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"is offline or not installed - "
|
2009-03-26 08:23:49 -06:00
|
|
|
"INTERVENTION REQUIRED!!\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dasd_3990_erp_block_queue(erp, 60*HZ);
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_int_req */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_ALTERNATE_PATH
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Repeat the operation on a different channel path.
|
|
|
|
* If all alternate paths have been tried, the request is posted with a
|
|
|
|
* permanent error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp pointer to the current ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp modified pointer to the ERP
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dasd_3990_erp_alternate_path(struct dasd_ccw_req * erp)
|
|
|
|
{
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u8 opm;
|
2008-01-26 06:11:23 -07:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* try alternate valid path */
|
2008-01-26 06:11:23 -07:00
|
|
|
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
opm = ccw_device_get_path_mask(device->cdev);
|
2008-01-26 06:11:23 -07:00
|
|
|
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (erp->lpm == 0)
|
2016-08-08 07:53:54 -06:00
|
|
|
erp->lpm = dasd_path_get_opm(device) &
|
2011-01-05 04:48:03 -07:00
|
|
|
~(erp->irb.esw.esw0.sublog.lpum);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
|
|
|
erp->lpm &= ~(erp->irb.esw.esw0.sublog.lpum);
|
|
|
|
|
|
|
|
if ((erp->lpm & opm) != 0x00) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"try alternate lpm=%x (lpum=%x / opm=%x)",
|
|
|
|
erp->lpm, erp->irb.esw.esw0.sublog.lpum, opm);
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
/* reset status to submit the request again... */
|
|
|
|
erp->status = DASD_CQR_FILLED;
|
2008-02-05 08:50:46 -07:00
|
|
|
erp->retries = 10;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"The DASD cannot be reached on any path (lpum=%x"
|
|
|
|
"/opm=%x)\n", erp->irb.esw.esw0.sublog.lpum, opm);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* post request with permanent error */
|
2008-01-26 06:11:23 -07:00
|
|
|
erp->status = DASD_CQR_FAILED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} /* end dasd_3990_erp_alternate_path */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_DCTL
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
2006-06-29 06:58:12 -06:00
|
|
|
* Setup cqr to do the Diagnostic Control (DCTL) command with an
|
2005-04-16 16:20:36 -06:00
|
|
|
* Inhibit Write subcommand (0x20) and the given modifier.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp pointer to the current (failed) ERP
|
|
|
|
* modifier subcommand modifier
|
2006-06-29 06:58:12 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* RETURN VALUES
|
2006-06-29 06:58:12 -06:00
|
|
|
* dctl_cqr pointer to NEW dctl_cqr
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct DCTL_data *DCTL_data;
|
|
|
|
struct ccw1 *ccw;
|
|
|
|
struct dasd_ccw_req *dctl_cqr;
|
|
|
|
|
|
|
|
dctl_cqr = dasd_alloc_erp_request((char *) &erp->magic, 1,
|
2008-01-26 06:11:23 -07:00
|
|
|
sizeof(struct DCTL_data),
|
|
|
|
device);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (IS_ERR(dctl_cqr)) {
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"Unable to allocate DCTL-CQR\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->status = DASD_CQR_FAILED;
|
|
|
|
return erp;
|
|
|
|
}
|
|
|
|
|
|
|
|
DCTL_data = dctl_cqr->data;
|
|
|
|
|
|
|
|
DCTL_data->subcommand = 0x02; /* Inhibit Write */
|
|
|
|
DCTL_data->modifier = modifier;
|
|
|
|
|
|
|
|
ccw = dctl_cqr->cpaddr;
|
2008-01-26 06:11:23 -07:00
|
|
|
memset(ccw, 0, sizeof(struct ccw1));
|
2005-04-16 16:20:36 -06:00
|
|
|
ccw->cmd_code = CCW_CMD_DCTL;
|
|
|
|
ccw->count = 4;
|
|
|
|
ccw->cda = (__u32)(addr_t) DCTL_data;
|
2010-10-25 08:10:08 -06:00
|
|
|
dctl_cqr->flags = erp->flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
dctl_cqr->function = dasd_3990_erp_DCTL;
|
|
|
|
dctl_cqr->refers = erp;
|
2008-01-26 06:11:23 -07:00
|
|
|
dctl_cqr->startdev = device;
|
|
|
|
dctl_cqr->memdev = device;
|
2005-04-16 16:20:36 -06:00
|
|
|
dctl_cqr->magic = erp->magic;
|
|
|
|
dctl_cqr->expires = 5 * 60 * HZ;
|
|
|
|
dctl_cqr->retries = 2;
|
|
|
|
|
2013-01-30 01:49:40 -07:00
|
|
|
dctl_cqr->buildclk = get_tod_clock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dctl_cqr->status = DASD_CQR_FILLED;
|
|
|
|
|
|
|
|
return dctl_cqr;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_DCTL */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_ACTION_1
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Setup ERP to do the ERP action 1 (see Reference manual).
|
|
|
|
* Repeat the operation on a different channel path.
|
2009-12-07 04:51:51 -07:00
|
|
|
* As deviation from the recommended recovery action, we reset the path mask
|
|
|
|
* after we have tried each path and go through all paths a second time.
|
|
|
|
* This will cover situations where only one path at a time is actually down,
|
|
|
|
* but all paths fail and recover just with the same sequence and timing as
|
|
|
|
* we try to use them (flapping links).
|
|
|
|
* If all alternate paths have been tried twice, the request is posted with
|
|
|
|
* a permanent error.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp pointer to the current ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp pointer to the ERP
|
|
|
|
*
|
|
|
|
*/
|
2009-12-07 04:51:51 -07:00
|
|
|
static struct dasd_ccw_req *dasd_3990_erp_action_1_sec(struct dasd_ccw_req *erp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-12-07 04:51:51 -07:00
|
|
|
erp->function = dasd_3990_erp_action_1_sec;
|
|
|
|
dasd_3990_erp_alternate_path(erp);
|
|
|
|
return erp;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-12-07 04:51:51 -07:00
|
|
|
static struct dasd_ccw_req *dasd_3990_erp_action_1(struct dasd_ccw_req *erp)
|
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->function = dasd_3990_erp_action_1;
|
|
|
|
dasd_3990_erp_alternate_path(erp);
|
2011-01-05 04:48:03 -07:00
|
|
|
if (erp->status == DASD_CQR_FAILED &&
|
|
|
|
!test_bit(DASD_CQR_VERIFY_PATH, &erp->flags)) {
|
2009-12-07 04:51:51 -07:00
|
|
|
erp->status = DASD_CQR_FILLED;
|
|
|
|
erp->retries = 10;
|
2016-08-08 07:53:54 -06:00
|
|
|
erp->lpm = dasd_path_get_opm(erp->startdev);
|
2009-12-07 04:51:51 -07:00
|
|
|
erp->function = dasd_3990_erp_action_1_sec;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return erp;
|
2009-12-07 04:51:51 -07:00
|
|
|
} /* end dasd_3990_erp_action_1(b) */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_ACTION_4
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Setup ERP to do the ERP action 4 (see Reference manual).
|
|
|
|
* Set the current request to PENDING to block the CQR queue for that device
|
|
|
|
* until the state change interrupt appears.
|
|
|
|
* Use a timer (20 seconds) to retry the cqr if the interrupt is still
|
|
|
|
* missing.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
* erp pointer to the current ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp pointer to the ERP
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_action_4(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* first time set initial retry counter and erp_function */
|
|
|
|
/* and retry once without waiting for state change pending */
|
|
|
|
/* interrupt (this enables easier enqueing of the cqr) */
|
|
|
|
if (erp->function != dasd_3990_erp_action_4) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_INFO, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"dasd_3990_erp_action_4: first time retry");
|
|
|
|
|
|
|
|
erp->retries = 256;
|
|
|
|
erp->function = dasd_3990_erp_action_4;
|
|
|
|
|
|
|
|
} else {
|
2008-02-05 08:50:46 -07:00
|
|
|
if (sense && (sense[25] == 0x1D)) { /* state change pending */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_INFO, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"waiting for state change pending "
|
|
|
|
"interrupt, %d retries left",
|
|
|
|
erp->retries);
|
2006-06-29 06:58:12 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dasd_3990_erp_block_queue(erp, 30*HZ);
|
|
|
|
|
2008-02-05 08:50:46 -07:00
|
|
|
} else if (sense && (sense[25] == 0x1E)) { /* busy */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_INFO, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"busy - redriving request later, "
|
|
|
|
"%d retries left",
|
|
|
|
erp->retries);
|
|
|
|
dasd_3990_erp_block_queue(erp, HZ);
|
|
|
|
} else {
|
|
|
|
/* no state change pending - retry */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_INFO, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"redriving request immediately, "
|
2006-06-29 06:58:12 -06:00
|
|
|
"%d retries left",
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->retries);
|
2008-01-26 06:11:23 -07:00
|
|
|
erp->status = DASD_CQR_FILLED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_action_4 */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
* 24 byte sense ERP functions (only)
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_ACTION_5
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Setup ERP to do the ERP action 5 (see Reference manual).
|
|
|
|
* NOTE: Further handling is done in xxx_further_erp after the retries.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp pointer to the current ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp pointer to the ERP
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_action_5(struct dasd_ccw_req * erp)
|
|
|
|
{
|
|
|
|
|
|
|
|
/* first of all retry */
|
|
|
|
erp->retries = 10;
|
|
|
|
erp->function = dasd_3990_erp_action_5;
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_action_5 */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_HANDLE_ENV_DATA
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'Environmental data present'.
|
|
|
|
* Does a analysis of the sense data (message Format)
|
|
|
|
* and prints the error messages.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense current sense data
|
2006-06-29 06:58:12 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* RETURN VALUES
|
|
|
|
* void
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dasd_3990_handle_env_data(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
char msg_format = (sense[7] & 0xF0);
|
|
|
|
char msg_no = (sense[7] & 0x0F);
|
2009-03-26 08:23:49 -06:00
|
|
|
char errorstring[ERRORLENGTH];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (msg_format) {
|
|
|
|
case 0x00: /* Format 0 - Program or System Checks */
|
|
|
|
|
|
|
|
if (sense[1] & 0x10) { /* check message to operator bit */
|
|
|
|
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00: /* No Message */
|
|
|
|
break;
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Invalid Command\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x02:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - Invalid Command "
|
2009-03-26 08:23:49 -06:00
|
|
|
"Sequence\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x03:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - CCW Count less than "
|
2009-03-26 08:23:49 -06:00
|
|
|
"required\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x04:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Invalid Parameter\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x05:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Diagnostic of Special"
|
|
|
|
" Command Violates File Mask\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x07:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - Channel Returned with "
|
2009-03-26 08:23:49 -06:00
|
|
|
"Incorrect retry CCW\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x08:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Reset Notification\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x09:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Storage Path Restart\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0A:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - Channel requested "
|
2009-03-26 08:23:49 -06:00
|
|
|
"... %02x\n", sense[8]);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0B:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - Invalid Defective/"
|
2009-03-26 08:23:49 -06:00
|
|
|
"Alternate Track Pointer\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0C:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - DPS Installation "
|
2009-03-26 08:23:49 -06:00
|
|
|
"Check\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0E:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - Command Invalid on "
|
2009-03-26 08:23:49 -06:00
|
|
|
"Secondary Address\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0F:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - Status Not As "
|
2009-03-26 08:23:49 -06:00
|
|
|
"Required: reason %02x\n",
|
|
|
|
sense[8]);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00: /* No Message */
|
|
|
|
break;
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Device Error "
|
|
|
|
"Source\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x02:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x03:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - Device Fenced - "
|
2009-03-26 08:23:49 -06:00
|
|
|
"device = %02x\n", sense[4]);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x04:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 0 - Data Pinned for "
|
2009-03-26 08:23:49 -06:00
|
|
|
"Device\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 0 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x10: /* Format 1 - Device Equipment Checks */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00: /* No Message */
|
|
|
|
break;
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 1 - Device Status 1 not as "
|
2009-03-26 08:23:49 -06:00
|
|
|
"expected\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x03:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 1 - Index missing\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x04:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 1 - Interruption cannot be "
|
|
|
|
"reset\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x05:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 1 - Device did not respond to "
|
2009-03-26 08:23:49 -06:00
|
|
|
"selection\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x06:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 1 - Device check-2 error or Set "
|
2009-03-26 08:23:49 -06:00
|
|
|
"Sector is not complete\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x07:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 1 - Head address does not "
|
2009-03-26 08:23:49 -06:00
|
|
|
"compare\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x08:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 1 - Device status 1 not valid\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x09:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 1 - Device not ready\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0A:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 1 - Track physical address did "
|
2009-03-26 08:23:49 -06:00
|
|
|
"not compare\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0B:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 1 - Missing device address bit\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0C:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 1 - Drive motor switch is off\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0D:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 1 - Seek incomplete\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0E:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 1 - Cylinder address did not "
|
2009-03-26 08:23:49 -06:00
|
|
|
"compare\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0F:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 1 - Offset active cannot be "
|
2009-03-26 08:23:49 -06:00
|
|
|
"reset\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 1 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x20: /* Format 2 - 3990 Equipment Checks */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x08:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 2 - 3990 check-2 error\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0E:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 2 - Support facility errors\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0F:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 2 - Microcode detected error "
|
|
|
|
"%02x\n",
|
|
|
|
sense[8]);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 2 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x30: /* Format 3 - 3990 Control Checks */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x0F:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 3 - Allegiance terminated\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 3 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x40: /* Format 4 - Data Checks */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 4 - Home address area error\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 4 - Count area error\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x02:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 4 - Key area error\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x03:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 4 - Data area error\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x04:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 4 - No sync byte in home address "
|
2009-03-26 08:23:49 -06:00
|
|
|
"area\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x05:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 4 - No sync byte in count address "
|
2009-03-26 08:23:49 -06:00
|
|
|
"area\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x06:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 4 - No sync byte in key area\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x07:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 4 - No sync byte in data area\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x08:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 4 - Home address area error; "
|
2009-03-26 08:23:49 -06:00
|
|
|
"offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x09:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 4 - Count area error; offset "
|
2009-03-26 08:23:49 -06:00
|
|
|
"active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0A:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 4 - Key area error; offset "
|
2009-03-26 08:23:49 -06:00
|
|
|
"active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0B:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 4 - Data area error; "
|
2009-03-26 08:23:49 -06:00
|
|
|
"offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0C:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 4 - No sync byte in home "
|
2009-03-26 08:23:49 -06:00
|
|
|
"address area; offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0D:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2016-11-18 06:39:05 -07:00
|
|
|
"FORMAT 4 - No sync byte in count "
|
2009-03-26 08:23:49 -06:00
|
|
|
"address area; offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0E:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 4 - No sync byte in key area; "
|
2009-03-26 08:23:49 -06:00
|
|
|
"offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0F:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2016-11-18 06:39:05 -07:00
|
|
|
"FORMAT 4 - No sync byte in data area; "
|
2009-03-26 08:23:49 -06:00
|
|
|
"offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 4 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x50: /* Format 5 - Data Check with displacement information */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 5 - Data Check in the "
|
2009-03-26 08:23:49 -06:00
|
|
|
"home address area\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 5 - Data Check in the count "
|
|
|
|
"area\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x02:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 5 - Data Check in the key area\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x03:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 5 - Data Check in the data "
|
|
|
|
"area\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x08:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 5 - Data Check in the "
|
2009-03-26 08:23:49 -06:00
|
|
|
"home address area; offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x09:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 5 - Data Check in the count area; "
|
2009-03-26 08:23:49 -06:00
|
|
|
"offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0A:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 5 - Data Check in the key area; "
|
2009-03-26 08:23:49 -06:00
|
|
|
"offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0B:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 5 - Data Check in the data area; "
|
2009-03-26 08:23:49 -06:00
|
|
|
"offset active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 5 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x60: /* Format 6 - Usage Statistics/Overrun Errors */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Overrun on channel A\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Overrun on channel B\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x02:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Overrun on channel C\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x03:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Overrun on channel D\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x04:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Overrun on channel E\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x05:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Overrun on channel F\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x06:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Overrun on channel G\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x07:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Overrun on channel H\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 6 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x70: /* Format 7 - Device Connection Control Checks */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - RCC initiated by a connection "
|
2009-03-26 08:23:49 -06:00
|
|
|
"check alert\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - RCC 1 sequence not "
|
2009-03-26 08:23:49 -06:00
|
|
|
"successful\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x02:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - RCC 1 and RCC 2 sequences not "
|
2009-03-26 08:23:49 -06:00
|
|
|
"successful\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x03:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - Invalid tag-in during "
|
2009-03-26 08:23:49 -06:00
|
|
|
"selection sequence\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x04:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 7 - extra RCC required\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x05:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - Invalid DCC selection "
|
2009-03-26 08:23:49 -06:00
|
|
|
"response or timeout\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x06:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - Missing end operation; device "
|
2009-03-26 08:23:49 -06:00
|
|
|
"transfer complete\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x07:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - Missing end operation; device "
|
2009-03-26 08:23:49 -06:00
|
|
|
"transfer incomplete\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x08:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - Invalid tag-in for an "
|
2009-03-26 08:23:49 -06:00
|
|
|
"immediate command sequence\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x09:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - Invalid tag-in for an "
|
2009-03-26 08:23:49 -06:00
|
|
|
"extended command sequence\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0A:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - 3990 microcode time out when "
|
2009-03-26 08:23:49 -06:00
|
|
|
"stopping selection\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0B:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - No response to selection "
|
2009-03-26 08:23:49 -06:00
|
|
|
"after a poll interruption\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0C:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - Permanent path error (DASD "
|
2009-03-26 08:23:49 -06:00
|
|
|
"controller not available)\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0D:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 7 - DASD controller not available"
|
2009-03-26 08:23:49 -06:00
|
|
|
" on disconnected command chain\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 7 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x80: /* Format 8 - Additional Device Equipment Checks */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00: /* No Message */
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 8 - Error correction code "
|
2009-03-26 08:23:49 -06:00
|
|
|
"hardware fault\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x03:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 8 - Unexpected end operation "
|
2009-03-26 08:23:49 -06:00
|
|
|
"response code\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x04:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 8 - End operation with transfer "
|
2009-03-26 08:23:49 -06:00
|
|
|
"count not zero\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x05:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 8 - End operation with transfer "
|
2009-03-26 08:23:49 -06:00
|
|
|
"count zero\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x06:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 8 - DPS checks after a system "
|
2009-03-26 08:23:49 -06:00
|
|
|
"reset or selective reset\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x07:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 8 - DPS cannot be filled\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x08:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 8 - Short busy time-out during "
|
2009-03-26 08:23:49 -06:00
|
|
|
"device selection\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x09:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 8 - DASD controller failed to "
|
2009-03-26 08:23:49 -06:00
|
|
|
"set or reset the long busy latch\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0A:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 8 - No interruption from device "
|
2009-03-26 08:23:49 -06:00
|
|
|
"during a command chain\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 8 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x90: /* Format 9 - Device Read, Write, and Seek Checks */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00:
|
|
|
|
break; /* No Message */
|
|
|
|
case 0x06:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 9 - Device check-2 error\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x07:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 9 - Head address did not "
|
|
|
|
"compare\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0A:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 9 - Track physical address did "
|
2009-03-26 08:23:49 -06:00
|
|
|
"not compare while oriented\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0E:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT 9 - Cylinder address did not "
|
2009-03-26 08:23:49 -06:00
|
|
|
"compare\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT 9 - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xF0: /* Format F - Cache Storage Checks */
|
|
|
|
switch (msg_no) {
|
|
|
|
case 0x00:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT F - Operation Terminated\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x01:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT F - Subsystem Processing Error\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x02:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT F - Cache or nonvolatile storage "
|
2009-03-26 08:23:49 -06:00
|
|
|
"equipment failure\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x04:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT F - Caching terminated\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x06:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT F - Cache fast write access not "
|
2009-03-26 08:23:49 -06:00
|
|
|
"authorized\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x07:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT F - Track format incorrect\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x09:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT F - Caching reinitiated\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0A:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT F - Nonvolatile storage "
|
2009-03-26 08:23:49 -06:00
|
|
|
"terminated\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0B:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT F - Volume is suspended duplex\n");
|
2006-03-24 04:15:25 -07:00
|
|
|
/* call extended error reporting (EER) */
|
|
|
|
dasd_eer_write(device, erp->refers,
|
|
|
|
DASD_EER_PPRCSUSPEND);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0C:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT F - Subsystem status cannot be "
|
|
|
|
"determined\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0D:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"FORMAT F - Caching status reset to "
|
2009-03-26 08:23:49 -06:00
|
|
|
"default\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0x0E:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
|
|
|
"FORMAT F - DASD Fast Write inhibited\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev,
|
2016-11-18 06:39:05 -07:00
|
|
|
"FORMAT F - Reserved\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
default: /* unknown message format - should not happen
|
|
|
|
internal error 03 - unknown message format */
|
|
|
|
snprintf(errorstring, ERRORLENGTH, "03 %x02", msg_format);
|
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"An error occurred in the DASD device driver, "
|
|
|
|
"reason=%s\n", errorstring);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
} /* end switch message format */
|
|
|
|
|
|
|
|
} /* end dasd_3990_handle_env_data */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_COM_REJ
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'Command Reject' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
|
|
|
* sense current sense data
|
2006-06-29 06:58:12 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* RETURN VALUES
|
2006-06-29 06:58:12 -06:00
|
|
|
* erp 'new' erp_head - pointer to new ERP
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_com_rej(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_com_rej;
|
|
|
|
|
|
|
|
/* env data present (ACTION 10 - retry should work) */
|
|
|
|
if (sense[2] & SNS2_ENV_DATA_PRESENT) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Command Reject - environmental data present");
|
|
|
|
|
|
|
|
dasd_3990_handle_env_data(erp, sense);
|
|
|
|
|
|
|
|
erp->retries = 5;
|
|
|
|
|
2010-03-08 04:26:24 -07:00
|
|
|
} else if (sense[1] & SNS1_WRITE_INHIBITED) {
|
|
|
|
dev_err(&device->cdev->dev, "An I/O request was rejected"
|
|
|
|
" because writing is inhibited\n");
|
|
|
|
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2009-03-26 08:23:49 -06:00
|
|
|
/* fatal error - set status to FAILED
|
|
|
|
internal error 09 - Command Reject */
|
2017-03-22 04:06:20 -06:00
|
|
|
if (!test_bit(DASD_CQR_SUPPRESS_CR, &erp->flags))
|
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"An error occurred in the DASD device driver, reason=09\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_com_rej */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_BUS_OUT
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'Bus Out Parity Check' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp new erp_head - pointer to new ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_bus_out(struct dasd_ccw_req * erp)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* first time set initial retry counter and erp_function */
|
|
|
|
/* and retry once without blocking queue */
|
|
|
|
/* (this enables easier enqueing of the cqr) */
|
|
|
|
if (erp->function != dasd_3990_erp_bus_out) {
|
|
|
|
erp->retries = 256;
|
|
|
|
erp->function = dasd_3990_erp_bus_out;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* issue a message and wait for 'device ready' interrupt */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"bus out parity error or BOPC requested by "
|
|
|
|
"channel");
|
|
|
|
|
|
|
|
dasd_3990_erp_block_queue(erp, 60*HZ);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_bus_out */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_EQUIP_CHECK
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'Equipment Check' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp new erp_head - pointer to new ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_equip_check(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_equip_check;
|
|
|
|
|
|
|
|
if (sense[1] & SNS1_WRITE_INHIBITED) {
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_info(&device->cdev->dev,
|
|
|
|
"Write inhibited path encountered\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
/* vary path offline
|
|
|
|
internal error 04 - Path should be varied off-line.*/
|
|
|
|
dev_err(&device->cdev->dev, "An error occurred in the DASD "
|
|
|
|
"device driver, reason=%s\n", "04");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_1(erp);
|
|
|
|
|
|
|
|
} else if (sense[2] & SNS2_ENV_DATA_PRESENT) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Equipment Check - " "environmental data present");
|
|
|
|
|
|
|
|
dasd_3990_handle_env_data(erp, sense);
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_4(erp, sense);
|
|
|
|
|
|
|
|
} else if (sense[1] & SNS1_PERM_ERR) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Equipment Check - retry exhausted or "
|
|
|
|
"undesirable");
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_1(erp);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* all other equipment checks - Action 5 */
|
|
|
|
/* rest is done when retries == 0 */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Equipment check or processing error");
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_5(erp);
|
|
|
|
}
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_equip_check */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_DATA_CHECK
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'Data Check' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp new erp_head - pointer to new ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_data_check(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_data_check;
|
|
|
|
|
|
|
|
if (sense[2] & SNS2_CORRECTABLE) { /* correctable data check */
|
|
|
|
|
|
|
|
/* issue message that the data has been corrected */
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_emerg(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"Data recovered during retry with PCI "
|
2009-03-26 08:23:49 -06:00
|
|
|
"fetch mode active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* not possible to handle this situation in Linux */
|
|
|
|
panic("No way to inform application about the possibly "
|
|
|
|
"incorrect data");
|
|
|
|
|
|
|
|
} else if (sense[2] & SNS2_ENV_DATA_PRESENT) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Uncorrectable data check recovered secondary "
|
|
|
|
"addr of duplex pair");
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_4(erp, sense);
|
|
|
|
|
|
|
|
} else if (sense[1] & SNS1_PERM_ERR) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Uncorrectable data check with internal "
|
|
|
|
"retry exhausted");
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_1(erp);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* all other data checks */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Uncorrectable data check with retry count "
|
|
|
|
"exhausted...");
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_5(erp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_data_check */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_OVERRUN
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'Overrun' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp new erp_head - pointer to new ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_overrun(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_overrun;
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Overrun - service overrun or overrun"
|
|
|
|
" error requested by channel");
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_5(erp);
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_overrun */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_INV_FORMAT
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'Invalid Track Format' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp new erp_head - pointer to new ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_inv_format(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_inv_format;
|
|
|
|
|
|
|
|
if (sense[2] & SNS2_ENV_DATA_PRESENT) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Track format error when destaging or "
|
|
|
|
"staging data");
|
|
|
|
|
|
|
|
dasd_3990_handle_env_data(erp, sense);
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_4(erp, sense);
|
|
|
|
|
|
|
|
} else {
|
2009-03-26 08:23:49 -06:00
|
|
|
/* internal error 06 - The track format is not valid*/
|
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"An error occurred in the DASD device driver, "
|
|
|
|
"reason=%s\n", "06");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_inv_format */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_EOC
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'End-of-Cylinder' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp already added default erp
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp pointer to original (failed) cqr.
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_EOC(struct dasd_ccw_req * default_erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = default_erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"The cylinder data for accessing the DASD is inconsistent\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* implement action 7 - BUG */
|
|
|
|
return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_EOC */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_ENV_DATA
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'Environmental-Data Present' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp new erp_head - pointer to new ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_env_data(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_env_data;
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s", "Environmental data present");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dasd_3990_handle_env_data(erp, sense);
|
|
|
|
|
|
|
|
/* don't retry on disabled interface */
|
|
|
|
if (sense[7] != 0x0F) {
|
|
|
|
erp = dasd_3990_erp_action_4(erp, sense);
|
|
|
|
} else {
|
2008-01-26 06:11:23 -07:00
|
|
|
erp->status = DASD_CQR_FILLED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_env_data */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_NO_REC
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'No Record Found' error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp already added default ERP
|
2006-06-29 06:58:12 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* RETURN VALUES
|
|
|
|
* erp new erp_head - pointer to new ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_no_rec(struct dasd_ccw_req * default_erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = default_erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-08-19 05:41:20 -06:00
|
|
|
/*
|
|
|
|
* In some cases the 'No Record Found' error might be expected and
|
|
|
|
* log messages shouldn't be written then.
|
|
|
|
* Check if the according suppress bit is set.
|
|
|
|
*/
|
|
|
|
if (!test_bit(DASD_CQR_SUPPRESS_NRF, &default_erp->flags))
|
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"The specified record was not found\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_no_rec */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_FILE_PROT
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 24 byte 'File Protected' error.
|
|
|
|
* Note: Seek related recovery is not implemented because
|
|
|
|
* wee don't use the seek command yet.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp new erp_head - pointer to new ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_file_prot(struct dasd_ccw_req * erp)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-08-19 05:41:20 -06:00
|
|
|
/*
|
|
|
|
* In some cases the 'File Protected' error might be expected and
|
|
|
|
* log messages shouldn't be written then.
|
|
|
|
* Check if the according suppress bit is set.
|
|
|
|
*/
|
|
|
|
if (!test_bit(DASD_CQR_SUPPRESS_FP, &erp->flags))
|
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"Accessing the DASD failed because of a hardware error\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_file_prot */
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_INSPECT_ALIAS
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Checks if the original request was started on an alias device.
|
|
|
|
* If yes, it modifies the original and the erp request so that
|
|
|
|
* the erp request can be started on a base device.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp pointer to the currently created default ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp pointer to the modified ERP, or NULL
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct dasd_ccw_req *dasd_3990_erp_inspect_alias(
|
|
|
|
struct dasd_ccw_req *erp)
|
|
|
|
{
|
|
|
|
struct dasd_ccw_req *cqr = erp->refers;
|
2010-05-17 02:00:10 -06:00
|
|
|
char *sense;
|
2008-01-26 06:11:23 -07:00
|
|
|
|
|
|
|
if (cqr->block &&
|
|
|
|
(cqr->block->base != cqr->startdev)) {
|
2010-05-17 02:00:10 -06:00
|
|
|
|
|
|
|
sense = dasd_get_sense(&erp->refers->irb);
|
|
|
|
/*
|
|
|
|
* dynamic pav may have changed base alias mapping
|
|
|
|
*/
|
|
|
|
if (!test_bit(DASD_FLAG_OFFLINE, &cqr->startdev->flags) && sense
|
|
|
|
&& (sense[0] == 0x10) && (sense[7] == 0x0F)
|
|
|
|
&& (sense[8] == 0x67)) {
|
|
|
|
/*
|
|
|
|
* remove device from alias handling to prevent new
|
|
|
|
* requests from being scheduled on the
|
|
|
|
* wrong alias device
|
|
|
|
*/
|
|
|
|
dasd_alias_remove_device(cqr->startdev);
|
|
|
|
|
|
|
|
/* schedule worker to reload device */
|
|
|
|
dasd_reload_device(cqr->startdev);
|
|
|
|
}
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
if (cqr->startdev->features & DASD_FEATURE_ERPLOG) {
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_ERR, cqr->startdev,
|
2008-01-26 06:11:23 -07:00
|
|
|
"ERP on alias device for request %p,"
|
|
|
|
" recover on base device %s", cqr,
|
2008-10-10 13:33:09 -06:00
|
|
|
dev_name(&cqr->block->base->cdev->dev));
|
2008-01-26 06:11:23 -07:00
|
|
|
}
|
|
|
|
dasd_eckd_reset_ccw_to_base_io(cqr);
|
|
|
|
erp->startdev = cqr->block->base;
|
|
|
|
erp->function = dasd_3990_erp_inspect_alias;
|
|
|
|
return erp;
|
|
|
|
} else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_INSPECT_24
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Does a detailed inspection of the 24 byte sense data
|
2006-06-29 06:58:12 -06:00
|
|
|
* and sets up a related error recovery action.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
* erp pointer to the currently created default ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp pointer to the (addtitional) ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_inspect_24(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct dasd_ccw_req *erp_filled = NULL;
|
|
|
|
|
|
|
|
/* Check sense for .... */
|
|
|
|
/* 'Command Reject' */
|
|
|
|
if ((erp_filled == NULL) && (sense[0] & SNS0_CMD_REJECT)) {
|
|
|
|
erp_filled = dasd_3990_erp_com_rej(erp, sense);
|
|
|
|
}
|
|
|
|
/* 'Intervention Required' */
|
|
|
|
if ((erp_filled == NULL) && (sense[0] & SNS0_INTERVENTION_REQ)) {
|
|
|
|
erp_filled = dasd_3990_erp_int_req(erp);
|
|
|
|
}
|
|
|
|
/* 'Bus Out Parity Check' */
|
|
|
|
if ((erp_filled == NULL) && (sense[0] & SNS0_BUS_OUT_CHECK)) {
|
|
|
|
erp_filled = dasd_3990_erp_bus_out(erp);
|
|
|
|
}
|
|
|
|
/* 'Equipment Check' */
|
|
|
|
if ((erp_filled == NULL) && (sense[0] & SNS0_EQUIPMENT_CHECK)) {
|
|
|
|
erp_filled = dasd_3990_erp_equip_check(erp, sense);
|
|
|
|
}
|
|
|
|
/* 'Data Check' */
|
|
|
|
if ((erp_filled == NULL) && (sense[0] & SNS0_DATA_CHECK)) {
|
|
|
|
erp_filled = dasd_3990_erp_data_check(erp, sense);
|
|
|
|
}
|
|
|
|
/* 'Overrun' */
|
|
|
|
if ((erp_filled == NULL) && (sense[0] & SNS0_OVERRUN)) {
|
|
|
|
erp_filled = dasd_3990_erp_overrun(erp, sense);
|
|
|
|
}
|
|
|
|
/* 'Invalid Track Format' */
|
|
|
|
if ((erp_filled == NULL) && (sense[1] & SNS1_INV_TRACK_FORMAT)) {
|
|
|
|
erp_filled = dasd_3990_erp_inv_format(erp, sense);
|
|
|
|
}
|
|
|
|
/* 'End-of-Cylinder' */
|
|
|
|
if ((erp_filled == NULL) && (sense[1] & SNS1_EOC)) {
|
|
|
|
erp_filled = dasd_3990_erp_EOC(erp, sense);
|
|
|
|
}
|
|
|
|
/* 'Environmental Data' */
|
|
|
|
if ((erp_filled == NULL) && (sense[2] & SNS2_ENV_DATA_PRESENT)) {
|
|
|
|
erp_filled = dasd_3990_erp_env_data(erp, sense);
|
|
|
|
}
|
|
|
|
/* 'No Record Found' */
|
|
|
|
if ((erp_filled == NULL) && (sense[1] & SNS1_NO_REC_FOUND)) {
|
|
|
|
erp_filled = dasd_3990_erp_no_rec(erp, sense);
|
|
|
|
}
|
|
|
|
/* 'File Protected' */
|
|
|
|
if ((erp_filled == NULL) && (sense[1] & SNS1_FILE_PROTECTED)) {
|
|
|
|
erp_filled = dasd_3990_erp_file_prot(erp);
|
|
|
|
}
|
|
|
|
/* other (unknown) error - do default ERP */
|
|
|
|
if (erp_filled == NULL) {
|
|
|
|
|
|
|
|
erp_filled = erp;
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp_filled;
|
|
|
|
|
|
|
|
} /* END dasd_3990_erp_inspect_24 */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
* 32 byte sense ERP functions (only)
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERPACTION_10_32
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 32 byte 'Action 10' of Single Program Action Codes.
|
|
|
|
* Just retry and if retry doesn't work, return with error.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp current erp_head
|
2006-06-29 06:58:12 -06:00
|
|
|
* sense current sense data
|
2005-04-16 16:20:36 -06:00
|
|
|
* RETURN VALUES
|
|
|
|
* erp modified erp_head
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_action_10_32(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->retries = 256;
|
|
|
|
erp->function = dasd_3990_erp_action_10_32;
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s", "Perform logging requested");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_action_10_32 */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_ACTION_1B_32
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles 32 byte 'Action 1B' of Single Program Action Codes.
|
2006-06-29 06:58:12 -06:00
|
|
|
* A write operation could not be finished because of an unexpected
|
2005-04-16 16:20:36 -06:00
|
|
|
* condition.
|
2006-06-29 06:58:12 -06:00
|
|
|
* The already created 'default erp' is used to get the link to
|
|
|
|
* the erp chain, but it can not be used for this recovery
|
2005-04-16 16:20:36 -06:00
|
|
|
* action because it contains no DE/LO data space.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* default_erp already added default erp.
|
2006-06-29 06:58:12 -06:00
|
|
|
* sense current sense data
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* RETURN VALUES
|
2006-06-29 06:58:12 -06:00
|
|
|
* erp new erp or
|
2005-04-16 16:20:36 -06:00
|
|
|
* default_erp in case of imprecise ending or error
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = default_erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u32 cpa = 0;
|
|
|
|
struct dasd_ccw_req *cqr;
|
|
|
|
struct dasd_ccw_req *erp;
|
|
|
|
struct DE_eckd_data *DE_data;
|
2008-01-26 06:11:23 -07:00
|
|
|
struct PFX_eckd_data *PFX_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
char *LO_data; /* LO_eckd_data_t */
|
2008-01-26 06:11:23 -07:00
|
|
|
struct ccw1 *ccw, *oldccw;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Write not finished because of unexpected condition");
|
|
|
|
|
|
|
|
default_erp->function = dasd_3990_erp_action_1B_32;
|
|
|
|
|
|
|
|
/* determine the original cqr */
|
|
|
|
cqr = default_erp;
|
|
|
|
|
|
|
|
while (cqr->refers != NULL) {
|
|
|
|
cqr = cqr->refers;
|
|
|
|
}
|
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
if (scsw_is_tm(&cqr->irb.scsw)) {
|
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
|
|
|
"32 bit sense, action 1B is not defined"
|
|
|
|
" in transport mode - just retry");
|
|
|
|
return default_erp;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* for imprecise ending just do default erp */
|
|
|
|
if (sense[1] & 0x01) {
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Imprecise ending is set - just retry");
|
|
|
|
|
|
|
|
return default_erp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* determine the address of the CCW to be restarted */
|
|
|
|
/* Imprecise ending is not set -> addr from IRB-SCSW */
|
2008-07-14 01:58:50 -06:00
|
|
|
cpa = default_erp->refers->irb.scsw.cmd.cpa;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (cpa == 0) {
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Unable to determine address of the CCW "
|
|
|
|
"to be restarted");
|
|
|
|
|
|
|
|
return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Build new ERP request including DE/LO */
|
|
|
|
erp = dasd_alloc_erp_request((char *) &cqr->magic,
|
|
|
|
2 + 1,/* DE/LO + TIC */
|
2008-01-26 06:11:23 -07:00
|
|
|
sizeof(struct DE_eckd_data) +
|
|
|
|
sizeof(struct LO_eckd_data), device);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (IS_ERR(erp)) {
|
2009-03-26 08:23:49 -06:00
|
|
|
/* internal error 01 - Unable to allocate ERP */
|
|
|
|
dev_err(&device->cdev->dev, "An error occurred in the DASD "
|
|
|
|
"device driver, reason=%s\n", "01");
|
2005-04-16 16:20:36 -06:00
|
|
|
return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* use original DE */
|
|
|
|
DE_data = erp->data;
|
2008-01-26 06:11:23 -07:00
|
|
|
oldccw = cqr->cpaddr;
|
|
|
|
if (oldccw->cmd_code == DASD_ECKD_CCW_PFX) {
|
|
|
|
PFX_data = cqr->data;
|
2009-03-26 08:23:48 -06:00
|
|
|
memcpy(DE_data, &PFX_data->define_extent,
|
2008-01-26 06:11:23 -07:00
|
|
|
sizeof(struct DE_eckd_data));
|
|
|
|
} else
|
|
|
|
memcpy(DE_data, cqr->data, sizeof(struct DE_eckd_data));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* create LO */
|
2008-01-26 06:11:23 -07:00
|
|
|
LO_data = erp->data + sizeof(struct DE_eckd_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
|
2009-03-26 08:23:49 -06:00
|
|
|
/* should not */
|
2005-04-16 16:20:36 -06:00
|
|
|
return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((sense[7] & 0x3F) == 0x01) {
|
|
|
|
/* operation code is WRITE DATA -> data area orientation */
|
|
|
|
LO_data[0] = 0x81;
|
|
|
|
|
|
|
|
} else if ((sense[7] & 0x3F) == 0x03) {
|
|
|
|
/* operation code is FORMAT WRITE -> index orientation */
|
|
|
|
LO_data[0] = 0xC3;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
LO_data[0] = sense[7]; /* operation */
|
|
|
|
}
|
|
|
|
|
|
|
|
LO_data[1] = sense[8]; /* auxiliary */
|
|
|
|
LO_data[2] = sense[9];
|
|
|
|
LO_data[3] = sense[3]; /* count */
|
|
|
|
LO_data[4] = sense[29]; /* seek_addr.cyl */
|
|
|
|
LO_data[5] = sense[30]; /* seek_addr.cyl 2nd byte */
|
|
|
|
LO_data[7] = sense[31]; /* seek_addr.head 2nd byte */
|
|
|
|
|
|
|
|
memcpy(&(LO_data[8]), &(sense[11]), 8);
|
|
|
|
|
|
|
|
/* create DE ccw */
|
|
|
|
ccw = erp->cpaddr;
|
2008-01-26 06:11:23 -07:00
|
|
|
memset(ccw, 0, sizeof(struct ccw1));
|
2005-04-16 16:20:36 -06:00
|
|
|
ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT;
|
|
|
|
ccw->flags = CCW_FLAG_CC;
|
|
|
|
ccw->count = 16;
|
|
|
|
ccw->cda = (__u32)(addr_t) DE_data;
|
|
|
|
|
|
|
|
/* create LO ccw */
|
|
|
|
ccw++;
|
2008-01-26 06:11:23 -07:00
|
|
|
memset(ccw, 0, sizeof(struct ccw1));
|
2005-04-16 16:20:36 -06:00
|
|
|
ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD;
|
|
|
|
ccw->flags = CCW_FLAG_CC;
|
|
|
|
ccw->count = 16;
|
|
|
|
ccw->cda = (__u32)(addr_t) LO_data;
|
|
|
|
|
|
|
|
/* TIC to the failed ccw */
|
|
|
|
ccw++;
|
|
|
|
ccw->cmd_code = CCW_CMD_TIC;
|
|
|
|
ccw->cda = cpa;
|
|
|
|
|
|
|
|
/* fill erp related fields */
|
2010-10-25 08:10:08 -06:00
|
|
|
erp->flags = default_erp->flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->function = dasd_3990_erp_action_1B_32;
|
|
|
|
erp->refers = default_erp->refers;
|
2008-01-26 06:11:23 -07:00
|
|
|
erp->startdev = device;
|
|
|
|
erp->memdev = device;
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->magic = default_erp->magic;
|
2011-12-27 03:27:23 -07:00
|
|
|
erp->expires = default_erp->expires;
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->retries = 256;
|
2013-01-30 01:49:40 -07:00
|
|
|
erp->buildclk = get_tod_clock();
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->status = DASD_CQR_FILLED;
|
|
|
|
|
|
|
|
/* remove the default erp */
|
|
|
|
dasd_free_erp_request(default_erp, device);
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_action_1B_32 */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_UPDATE_1B
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
2006-06-29 06:58:12 -06:00
|
|
|
* Handles the update to the 32 byte 'Action 1B' of Single Program
|
2005-04-16 16:20:36 -06:00
|
|
|
* Action Codes in case the first action was not successful.
|
|
|
|
* The already created 'previous_erp' is the currently not successful
|
2006-06-29 06:58:12 -06:00
|
|
|
* ERP.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* previous_erp already created previous erp.
|
2006-06-29 06:58:12 -06:00
|
|
|
* sense current sense data
|
2005-04-16 16:20:36 -06:00
|
|
|
* RETURN VALUES
|
2006-06-29 06:58:12 -06:00
|
|
|
* erp modified erp
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = previous_erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u32 cpa = 0;
|
|
|
|
struct dasd_ccw_req *cqr;
|
|
|
|
struct dasd_ccw_req *erp;
|
|
|
|
char *LO_data; /* struct LO_eckd_data */
|
|
|
|
struct ccw1 *ccw;
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Write not finished because of unexpected condition"
|
|
|
|
" - follow on");
|
|
|
|
|
|
|
|
/* determine the original cqr */
|
|
|
|
cqr = previous_erp;
|
|
|
|
|
|
|
|
while (cqr->refers != NULL) {
|
|
|
|
cqr = cqr->refers;
|
|
|
|
}
|
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
if (scsw_is_tm(&cqr->irb.scsw)) {
|
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
|
|
|
"32 bit sense, action 1B, update,"
|
|
|
|
" in transport mode - just retry");
|
|
|
|
return previous_erp;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* for imprecise ending just do default erp */
|
|
|
|
if (sense[1] & 0x01) {
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Imprecise ending is set - just retry");
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
previous_erp->status = DASD_CQR_FILLED;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return previous_erp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* determine the address of the CCW to be restarted */
|
|
|
|
/* Imprecise ending is not set -> addr from IRB-SCSW */
|
2008-07-14 01:58:50 -06:00
|
|
|
cpa = previous_erp->irb.scsw.cmd.cpa;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (cpa == 0) {
|
2009-03-26 08:23:49 -06:00
|
|
|
/* internal error 02 -
|
|
|
|
Unable to determine address of the CCW to be restarted */
|
|
|
|
dev_err(&device->cdev->dev, "An error occurred in the DASD "
|
|
|
|
"device driver, reason=%s\n", "02");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
previous_erp->status = DASD_CQR_FAILED;
|
|
|
|
|
|
|
|
return previous_erp;
|
|
|
|
}
|
|
|
|
|
|
|
|
erp = previous_erp;
|
|
|
|
|
|
|
|
/* update the LO with the new returned sense data */
|
2008-01-26 06:11:23 -07:00
|
|
|
LO_data = erp->data + sizeof(struct DE_eckd_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
|
2009-03-26 08:23:49 -06:00
|
|
|
/* should not happen */
|
2005-04-16 16:20:36 -06:00
|
|
|
previous_erp->status = DASD_CQR_FAILED;
|
|
|
|
|
|
|
|
return previous_erp;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((sense[7] & 0x3F) == 0x01) {
|
|
|
|
/* operation code is WRITE DATA -> data area orientation */
|
|
|
|
LO_data[0] = 0x81;
|
|
|
|
|
|
|
|
} else if ((sense[7] & 0x3F) == 0x03) {
|
|
|
|
/* operation code is FORMAT WRITE -> index orientation */
|
|
|
|
LO_data[0] = 0xC3;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
LO_data[0] = sense[7]; /* operation */
|
|
|
|
}
|
|
|
|
|
|
|
|
LO_data[1] = sense[8]; /* auxiliary */
|
|
|
|
LO_data[2] = sense[9];
|
|
|
|
LO_data[3] = sense[3]; /* count */
|
|
|
|
LO_data[4] = sense[29]; /* seek_addr.cyl */
|
|
|
|
LO_data[5] = sense[30]; /* seek_addr.cyl 2nd byte */
|
|
|
|
LO_data[7] = sense[31]; /* seek_addr.head 2nd byte */
|
|
|
|
|
|
|
|
memcpy(&(LO_data[8]), &(sense[11]), 8);
|
|
|
|
|
|
|
|
/* TIC to the failed ccw */
|
|
|
|
ccw = erp->cpaddr; /* addr of DE ccw */
|
|
|
|
ccw++; /* addr of LE ccw */
|
|
|
|
ccw++; /* addr of TIC ccw */
|
|
|
|
ccw->cda = cpa;
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
erp->status = DASD_CQR_FILLED;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_update_1B */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_COMPOUND_RETRY
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles the compound ERP action retry code.
|
|
|
|
* NOTE: At least one retry is done even if zero is specified
|
|
|
|
* by the sense data. This makes enqueueing of the request
|
|
|
|
* easier.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
* erp pointer to the currently created ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp modified ERP pointer
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dasd_3990_erp_compound_retry(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
|
|
|
switch (sense[25] & 0x03) {
|
|
|
|
case 0x00: /* no not retry */
|
|
|
|
erp->retries = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x01: /* retry 2 times */
|
|
|
|
erp->retries = 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x02: /* retry 10 times */
|
|
|
|
erp->retries = 10;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x03: /* retry 256 times */
|
|
|
|
erp->retries = 256;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_compound_retry;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_compound_retry */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_COMPOUND_PATH
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles the compound ERP action for retry on alternate
|
|
|
|
* channel path.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
* erp pointer to the currently created ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp modified ERP pointer
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dasd_3990_erp_compound_path(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
if (sense[25] & DASD_SENSE_BIT_3) {
|
|
|
|
dasd_3990_erp_alternate_path(erp);
|
|
|
|
|
2011-01-05 04:48:03 -07:00
|
|
|
if (erp->status == DASD_CQR_FAILED &&
|
|
|
|
!test_bit(DASD_CQR_VERIFY_PATH, &erp->flags)) {
|
2006-06-29 06:58:12 -06:00
|
|
|
/* reset the lpm and the status to be able to
|
2005-04-16 16:20:36 -06:00
|
|
|
* try further actions. */
|
2016-08-08 07:53:54 -06:00
|
|
|
erp->lpm = dasd_path_get_opm(erp->startdev);
|
2008-01-26 06:11:23 -07:00
|
|
|
erp->status = DASD_CQR_NEED_ERP;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_compound_path;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_compound_path */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_COMPOUND_CODE
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles the compound ERP action for retry code.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
* erp pointer to the currently created ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp NEW ERP pointer
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_compound_code(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (sense[25] & DASD_SENSE_BIT_2) {
|
|
|
|
|
|
|
|
switch (sense[28]) {
|
|
|
|
case 0x17:
|
2006-06-29 06:58:12 -06:00
|
|
|
/* issue a Diagnostic Control command with an
|
2007-10-19 15:10:43 -06:00
|
|
|
* Inhibit Write subcommand and controller modifier */
|
2005-04-16 16:20:36 -06:00
|
|
|
erp = dasd_3990_erp_DCTL(erp, 0x20);
|
|
|
|
break;
|
2006-06-29 06:58:12 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
case 0x25:
|
|
|
|
/* wait for 5 seconds and retry again */
|
|
|
|
erp->retries = 1;
|
2006-06-29 06:58:12 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dasd_3990_erp_block_queue (erp, 5*HZ);
|
|
|
|
break;
|
2006-06-29 06:58:12 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
default:
|
|
|
|
/* should not happen - continue */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_compound_code;
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_compound_code */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_COMPOUND_CONFIG
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Handles the compound ERP action for configruation
|
|
|
|
* dependent error.
|
|
|
|
* Note: duplex handling is not implemented (yet).
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
* erp pointer to the currently created ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp modified ERP pointer
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dasd_3990_erp_compound_config(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
|
|
|
if ((sense[25] & DASD_SENSE_BIT_1) && (sense[26] & DASD_SENSE_BIT_2)) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
/* set to suspended duplex state then restart
|
|
|
|
internal error 05 - Set device to suspended duplex state
|
|
|
|
should be done */
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"An error occurred in the DASD device driver, "
|
|
|
|
"reason=%s\n", "05");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_compound_config;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_compound_config */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_COMPOUND
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
2006-06-29 06:58:12 -06:00
|
|
|
* Does the further compound program action if
|
2005-04-16 16:20:36 -06:00
|
|
|
* compound retry was not successful.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
* erp pointer to the current (failed) ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp (additional) ERP pointer
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_compound(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
|
|
|
if ((erp->function == dasd_3990_erp_compound_retry) &&
|
2008-01-26 06:11:23 -07:00
|
|
|
(erp->status == DASD_CQR_NEED_ERP)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dasd_3990_erp_compound_path(erp, sense);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((erp->function == dasd_3990_erp_compound_path) &&
|
2008-01-26 06:11:23 -07:00
|
|
|
(erp->status == DASD_CQR_NEED_ERP)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_compound_code(erp, sense);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((erp->function == dasd_3990_erp_compound_code) &&
|
2008-01-26 06:11:23 -07:00
|
|
|
(erp->status == DASD_CQR_NEED_ERP)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dasd_3990_erp_compound_config(erp, sense);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if no compound action ERP specified, the request failed */
|
2008-01-26 06:11:23 -07:00
|
|
|
if (erp->status == DASD_CQR_NEED_ERP)
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->status = DASD_CQR_FAILED;
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_compound */
|
|
|
|
|
2008-04-16 23:46:08 -06:00
|
|
|
/*
|
|
|
|
*DASD_3990_ERP_HANDLE_SIM
|
|
|
|
*
|
|
|
|
*DESCRIPTION
|
|
|
|
* inspects the SIM SENSE data and starts an appropriate action
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* none
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
dasd_3990_erp_handle_sim(struct dasd_device *device, char *sense)
|
|
|
|
{
|
|
|
|
/* print message according to log or message to operator mode */
|
|
|
|
if ((sense[24] & DASD_SIM_MSG_TO_OP) || (sense[1] & 0x10)) {
|
|
|
|
/* print SIM SRC from RefCode */
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev, "SIM - SRC: "
|
|
|
|
"%02x%02x%02x%02x\n", sense[22],
|
2008-04-16 23:46:08 -06:00
|
|
|
sense[23], sense[11], sense[12]);
|
|
|
|
} else if (sense[24] & DASD_SIM_LOG) {
|
|
|
|
/* print SIM SRC Refcode */
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_warn(&device->cdev->dev, "log SIM - SRC: "
|
|
|
|
"%02x%02x%02x%02x\n", sense[22],
|
2008-04-16 23:46:08 -06:00
|
|
|
sense[23], sense[11], sense[12]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_INSPECT_32
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Does a detailed inspection of the 32 byte sense data
|
2006-06-29 06:58:12 -06:00
|
|
|
* and sets up a related error recovery action.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* sense sense data of the actual error
|
|
|
|
* erp pointer to the currently created default ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp_filled pointer to the ERP
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->function = dasd_3990_erp_inspect_32;
|
|
|
|
|
2008-04-16 23:46:08 -06:00
|
|
|
/* check for SIM sense data */
|
|
|
|
if ((sense[6] & DASD_SIM_SENSE) == DASD_SIM_SENSE)
|
|
|
|
dasd_3990_erp_handle_sim(device, sense);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sense[25] & DASD_SENSE_BIT_0) {
|
|
|
|
|
|
|
|
/* compound program action codes (byte25 bit 0 == '1') */
|
|
|
|
dasd_3990_erp_compound_retry(erp, sense);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* single program action codes (byte25 bit 0 == '0') */
|
|
|
|
switch (sense[25]) {
|
|
|
|
|
|
|
|
case 0x00: /* success - use default ERP for retries */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"ERP called for successful request"
|
|
|
|
" - just retry");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x01: /* fatal error */
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"ERP failed for the DASD\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x02: /* intervention required */
|
|
|
|
case 0x03: /* intervention required during dual copy */
|
|
|
|
erp = dasd_3990_erp_int_req(erp);
|
|
|
|
break;
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
case 0x0F: /* length mismatch during update write command
|
|
|
|
internal error 08 - update write command error*/
|
|
|
|
dev_err(&device->cdev->dev, "An error occurred in the "
|
|
|
|
"DASD device driver, reason=%s\n", "08");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x10: /* logging required for other channel program */
|
|
|
|
erp = dasd_3990_erp_action_10_32(erp, sense);
|
|
|
|
break;
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
case 0x15: /* next track outside defined extend
|
|
|
|
internal error 07 - The next track is not
|
|
|
|
within the defined storage extent */
|
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"An error occurred in the DASD device driver, "
|
|
|
|
"reason=%s\n", "07");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x1B: /* unexpected condition during write */
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_1B_32(erp, sense);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x1C: /* invalid data */
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_emerg(&device->cdev->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
"Data recovered during retry with PCI "
|
2009-03-26 08:23:49 -06:00
|
|
|
"fetch mode active\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* not possible to handle this situation in Linux */
|
|
|
|
panic
|
|
|
|
("Invalid data - No way to inform application "
|
|
|
|
"about the possibly incorrect data");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x1D: /* state-change pending */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"A State change pending condition exists "
|
|
|
|
"for the subsystem or device");
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_4(erp, sense);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x1E: /* busy */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Busy condition exists "
|
|
|
|
"for the subsystem or device");
|
|
|
|
erp = dasd_3990_erp_action_4(erp, sense);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default: /* all others errors - default erp */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_inspect_32 */
|
|
|
|
|
2016-08-08 07:56:54 -06:00
|
|
|
static void dasd_3990_erp_disable_path(struct dasd_device *device, __u8 lpum)
|
|
|
|
{
|
|
|
|
int pos = pathmask_to_pos(lpum);
|
|
|
|
|
|
|
|
/* no remaining path, cannot disable */
|
|
|
|
if (!(dasd_path_get_opm(device) & ~lpum))
|
|
|
|
return;
|
|
|
|
|
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"Path %x.%02x (pathmask %02x) is disabled - IFCC threshold exceeded\n",
|
|
|
|
device->path[pos].cssid, device->path[pos].chpid, lpum);
|
|
|
|
dasd_path_remove_opm(device, lpum);
|
|
|
|
dasd_path_add_ifccpm(device, lpum);
|
|
|
|
device->path[pos].errorclk = 0;
|
|
|
|
atomic_set(&device->path[pos].error_count, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dasd_3990_erp_account_error(struct dasd_ccw_req *erp)
|
|
|
|
{
|
|
|
|
struct dasd_device *device = erp->startdev;
|
|
|
|
__u8 lpum = erp->refers->irb.esw.esw1.lpum;
|
|
|
|
int pos = pathmask_to_pos(lpum);
|
2017-08-15 08:40:18 -06:00
|
|
|
unsigned long clk;
|
2016-08-08 07:56:54 -06:00
|
|
|
|
|
|
|
if (!device->path_thrhld)
|
|
|
|
return;
|
|
|
|
|
|
|
|
clk = get_tod_clock();
|
|
|
|
/*
|
|
|
|
* check if the last error is longer ago than the timeout,
|
|
|
|
* if so reset error state
|
|
|
|
*/
|
|
|
|
if ((tod_to_ns(clk - device->path[pos].errorclk) / NSEC_PER_SEC)
|
|
|
|
>= device->path_interval) {
|
|
|
|
atomic_set(&device->path[pos].error_count, 0);
|
|
|
|
device->path[pos].errorclk = 0;
|
|
|
|
}
|
|
|
|
atomic_inc(&device->path[pos].error_count);
|
|
|
|
device->path[pos].errorclk = clk;
|
|
|
|
/* threshold exceeded disable path if possible */
|
|
|
|
if (atomic_read(&device->path[pos].error_count) >=
|
|
|
|
device->path_thrhld)
|
|
|
|
dasd_3990_erp_disable_path(device, lpum);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2010-08-06 13:11:15 -06:00
|
|
|
* main ERP control functions (24 and 32 byte sense)
|
2006-06-29 06:58:12 -06:00
|
|
|
*****************************************************************************
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2008-02-05 08:50:46 -07:00
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_CONTROL_CHECK
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
2011-03-30 19:57:33 -06:00
|
|
|
* Does a generic inspection if a control check occurred and sets up
|
2008-02-05 08:50:46 -07:00
|
|
|
* the related error recovery procedure
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp pointer to the currently created default ERP
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp_filled pointer to the erp
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_control_check(struct dasd_ccw_req *erp)
|
|
|
|
{
|
|
|
|
struct dasd_device *device = erp->startdev;
|
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
if (scsw_cstat(&erp->refers->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK
|
2008-02-05 08:50:46 -07:00
|
|
|
| SCHN_STAT_CHN_CTRL_CHK)) {
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
|
2008-02-05 08:50:46 -07:00
|
|
|
"channel or interface control check");
|
2016-08-08 07:56:54 -06:00
|
|
|
dasd_3990_erp_account_error(erp);
|
2008-02-05 08:50:46 -07:00
|
|
|
erp = dasd_3990_erp_action_4(erp, NULL);
|
|
|
|
}
|
|
|
|
return erp;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_INSPECT
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Does a detailed inspection for sense data by calling either
|
|
|
|
* the 24-byte or the 32-byte inspection routine.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp pointer to the currently created default ERP
|
|
|
|
* RETURN VALUES
|
2006-06-29 06:58:12 -06:00
|
|
|
* erp_new contens was possibly modified
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
2009-03-26 08:23:48 -06:00
|
|
|
dasd_3990_erp_inspect(struct dasd_ccw_req *erp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
|
|
|
struct dasd_ccw_req *erp_new = NULL;
|
2009-03-26 08:23:48 -06:00
|
|
|
char *sense;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-30 19:57:33 -06:00
|
|
|
/* if this problem occurred on an alias retry on base */
|
2008-01-26 06:11:23 -07:00
|
|
|
erp_new = dasd_3990_erp_inspect_alias(erp);
|
|
|
|
if (erp_new)
|
|
|
|
return erp_new;
|
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
/* sense data are located in the refers record of the
|
|
|
|
* already set up new ERP !
|
|
|
|
* check if concurrent sens is available
|
|
|
|
*/
|
|
|
|
sense = dasd_get_sense(&erp->refers->irb);
|
|
|
|
if (!sense)
|
2008-02-05 08:50:46 -07:00
|
|
|
erp_new = dasd_3990_erp_control_check(erp);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* distinguish between 24 and 32 byte sense data */
|
2008-02-05 08:50:46 -07:00
|
|
|
else if (sense[27] & DASD_SENSE_BIT_0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* inspect the 24 byte sense data */
|
|
|
|
erp_new = dasd_3990_erp_inspect_24(erp, sense);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* inspect the 32 byte sense data */
|
|
|
|
erp_new = dasd_3990_erp_inspect_32(erp, sense);
|
|
|
|
|
|
|
|
} /* end distinguish between 24 and 32 byte sense data */
|
|
|
|
|
|
|
|
return erp_new;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_ADD_ERP
|
2006-06-29 06:58:12 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* DESCRIPTION
|
2011-03-30 19:57:33 -06:00
|
|
|
* This function adds an additional request block (ERP) to the head of
|
2005-04-16 16:20:36 -06:00
|
|
|
* the given cqr (or erp).
|
2009-03-26 08:23:48 -06:00
|
|
|
* For a command mode cqr the erp is initialized as an default erp
|
|
|
|
* (retry TIC).
|
|
|
|
* For transport mode we make a copy of the original TCW (points to
|
|
|
|
* the original TCCB, TIDALs, etc.) but give it a fresh
|
|
|
|
* TSB so the original sense data will not be changed.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* PARAMETER
|
2006-06-29 06:58:12 -06:00
|
|
|
* cqr head of the current ERP-chain (or single cqr if
|
2005-04-16 16:20:36 -06:00
|
|
|
* first error)
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp pointer to new ERP-chain head
|
|
|
|
*/
|
2009-03-26 08:23:48 -06:00
|
|
|
static struct dasd_ccw_req *dasd_3990_erp_add_erp(struct dasd_ccw_req *cqr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = cqr->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ccw1 *ccw;
|
|
|
|
struct dasd_ccw_req *erp;
|
2009-03-26 08:23:48 -06:00
|
|
|
int cplength, datasize;
|
|
|
|
struct tcw *tcw;
|
|
|
|
struct tsb *tsb;
|
|
|
|
|
|
|
|
if (cqr->cpmode == 1) {
|
|
|
|
cplength = 0;
|
2010-03-24 04:49:53 -06:00
|
|
|
/* TCW needs to be 64 byte aligned, so leave enough room */
|
|
|
|
datasize = 64 + sizeof(struct tcw) + sizeof(struct tsb);
|
2009-03-26 08:23:48 -06:00
|
|
|
} else {
|
|
|
|
cplength = 2;
|
|
|
|
datasize = 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
/* allocate additional request block */
|
|
|
|
erp = dasd_alloc_erp_request((char *) &cqr->magic,
|
|
|
|
cplength, datasize, device);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (IS_ERR(erp)) {
|
|
|
|
if (cqr->retries <= 0) {
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_ERR, device, "%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Unable to allocate ERP request");
|
|
|
|
cqr->status = DASD_CQR_FAILED;
|
2013-01-30 01:49:40 -07:00
|
|
|
cqr->stopclk = get_tod_clock();
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_ERR, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"Unable to allocate ERP request "
|
|
|
|
"(%i retries left)",
|
|
|
|
cqr->retries);
|
2008-01-26 06:11:23 -07:00
|
|
|
dasd_block_set_timer(device->block, (HZ << 3));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-04-22 09:17:02 -06:00
|
|
|
return erp;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-12-07 04:51:51 -07:00
|
|
|
ccw = cqr->cpaddr;
|
2009-03-26 08:23:48 -06:00
|
|
|
if (cqr->cpmode == 1) {
|
|
|
|
/* make a shallow copy of the original tcw but set new tsb */
|
|
|
|
erp->cpmode = 1;
|
2010-03-24 04:49:53 -06:00
|
|
|
erp->cpaddr = PTR_ALIGN(erp->data, 64);
|
|
|
|
tcw = erp->cpaddr;
|
2009-03-26 08:23:48 -06:00
|
|
|
tsb = (struct tsb *) &tcw[1];
|
|
|
|
*tcw = *((struct tcw *)cqr->cpaddr);
|
|
|
|
tcw->tsb = (long)tsb;
|
2009-12-07 04:51:51 -07:00
|
|
|
} else if (ccw->cmd_code == DASD_ECKD_CCW_PSF) {
|
|
|
|
/* PSF cannot be chained from NOOP/TIC */
|
|
|
|
erp->cpaddr = cqr->cpaddr;
|
2009-03-26 08:23:48 -06:00
|
|
|
} else {
|
|
|
|
/* initialize request with default TIC to current ERP/CQR */
|
|
|
|
ccw = erp->cpaddr;
|
|
|
|
ccw->cmd_code = CCW_CMD_NOOP;
|
|
|
|
ccw->flags = CCW_FLAG_CC;
|
|
|
|
ccw++;
|
|
|
|
ccw->cmd_code = CCW_CMD_TIC;
|
|
|
|
ccw->cda = (long)(cqr->cpaddr);
|
|
|
|
}
|
|
|
|
|
2010-10-25 08:10:08 -06:00
|
|
|
erp->flags = cqr->flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->function = dasd_3990_erp_add_erp;
|
|
|
|
erp->refers = cqr;
|
2008-01-26 06:11:23 -07:00
|
|
|
erp->startdev = device;
|
|
|
|
erp->memdev = device;
|
|
|
|
erp->block = cqr->block;
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->magic = cqr->magic;
|
2011-12-27 03:27:23 -07:00
|
|
|
erp->expires = cqr->expires;
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->retries = 256;
|
2013-01-30 01:49:40 -07:00
|
|
|
erp->buildclk = get_tod_clock();
|
2005-04-16 16:20:36 -06:00
|
|
|
erp->status = DASD_CQR_FILLED;
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_ADDITIONAL_ERP
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* DESCRIPTION
|
|
|
|
* An additional ERP is needed to handle the current error.
|
|
|
|
* Add ERP to the head of the ERP-chain containing the ERP processing
|
|
|
|
* determined based on the sense data.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
2006-06-29 06:58:12 -06:00
|
|
|
* cqr head of the current ERP-chain (or single cqr if
|
2005-04-16 16:20:36 -06:00
|
|
|
* first error)
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp pointer to new ERP-chain head
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_additional_erp(struct dasd_ccw_req * cqr)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct dasd_ccw_req *erp = NULL;
|
|
|
|
|
|
|
|
/* add erp and initialize with default TIC */
|
|
|
|
erp = dasd_3990_erp_add_erp(cqr);
|
|
|
|
|
2010-04-22 09:17:02 -06:00
|
|
|
if (IS_ERR(erp))
|
|
|
|
return erp;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* inspect sense, determine specific ERP if possible */
|
|
|
|
if (erp != cqr) {
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_inspect(erp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_additional_erp */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_ERROR_MATCH
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Check if the device status of the given cqr is the same.
|
|
|
|
* This means that the failed CCW and the relevant sense data
|
|
|
|
* must match.
|
|
|
|
* I don't distinguish between 24 and 32 byte sense because in case of
|
|
|
|
* 24 byte sense byte 25 and 27 is set as well.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
2006-06-29 06:58:12 -06:00
|
|
|
* cqr1 first cqr, which will be compared with the
|
2005-04-16 16:20:36 -06:00
|
|
|
* cqr2 second cqr.
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* match 'boolean' for match found
|
|
|
|
* returns 1 if match found, otherwise 0.
|
|
|
|
*/
|
2009-03-26 08:23:48 -06:00
|
|
|
static int dasd_3990_erp_error_match(struct dasd_ccw_req *cqr1,
|
|
|
|
struct dasd_ccw_req *cqr2)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-03-26 08:23:48 -06:00
|
|
|
char *sense1, *sense2;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-05 04:37:10 -07:00
|
|
|
if (cqr1->startdev != cqr2->startdev)
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
sense1 = dasd_get_sense(&cqr1->irb);
|
|
|
|
sense2 = dasd_get_sense(&cqr2->irb);
|
2008-02-05 08:50:46 -07:00
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
/* one request has sense data, the other not -> no match, return 0 */
|
|
|
|
if (!sense1 != !sense2)
|
|
|
|
return 0;
|
|
|
|
/* no sense data in both cases -> check cstat for IFCC */
|
|
|
|
if (!sense1 && !sense2) {
|
|
|
|
if ((scsw_cstat(&cqr1->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK |
|
|
|
|
SCHN_STAT_CHN_CTRL_CHK)) ==
|
|
|
|
(scsw_cstat(&cqr2->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK |
|
|
|
|
SCHN_STAT_CHN_CTRL_CHK)))
|
2008-02-05 08:50:46 -07:00
|
|
|
return 1; /* match with ifcc*/
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
/* check sense data; byte 0-2,25,27 */
|
2009-03-26 08:23:48 -06:00
|
|
|
if (!(sense1 && sense2 &&
|
|
|
|
(memcmp(sense1, sense2, 3) == 0) &&
|
|
|
|
(sense1[27] == sense2[27]) &&
|
|
|
|
(sense1[25] == sense2[25]))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0; /* sense doesn't match */
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1; /* match */
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_error_match */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_IN_ERP
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* check if the current error already happened before.
|
|
|
|
* quick exit if current cqr is not an ERP (cqr->refers=NULL)
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* cqr failed cqr (either original cqr or already an erp)
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
2006-06-29 06:58:12 -06:00
|
|
|
* erp erp-pointer to the already defined error
|
2005-04-16 16:20:36 -06:00
|
|
|
* recovery procedure OR
|
|
|
|
* NULL if a 'new' error occurred.
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_in_erp(struct dasd_ccw_req *cqr)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct dasd_ccw_req *erp_head = cqr, /* save erp chain head */
|
|
|
|
*erp_match = NULL; /* save erp chain head */
|
|
|
|
int match = 0; /* 'boolean' for matching error found */
|
|
|
|
|
|
|
|
if (cqr->refers == NULL) { /* return if not in erp */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check the erp/cqr chain for current error */
|
|
|
|
do {
|
|
|
|
match = dasd_3990_erp_error_match(erp_head, cqr->refers);
|
|
|
|
erp_match = cqr; /* save possible matching erp */
|
|
|
|
cqr = cqr->refers; /* check next erp/cqr in queue */
|
|
|
|
|
|
|
|
} while ((cqr->refers != NULL) && (!match));
|
|
|
|
|
|
|
|
if (!match) {
|
|
|
|
return NULL; /* no match was found */
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp_match; /* return address of matching erp */
|
|
|
|
|
|
|
|
} /* END dasd_3990_erp_in_erp */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_FURTHER_ERP (24 & 32 byte sense)
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
2006-06-29 06:58:12 -06:00
|
|
|
* No retry is left for the current ERP. Check what has to be done
|
2005-04-16 16:20:36 -06:00
|
|
|
* with the ERP.
|
|
|
|
* - do further defined ERP action or
|
2006-06-29 06:58:12 -06:00
|
|
|
* - wait for interrupt or
|
2005-04-16 16:20:36 -06:00
|
|
|
* - exit with permanent error
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp ERP which is in progress with no retry left
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp modified/additional ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_further_erp(struct dasd_ccw_req *erp)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp->startdev;
|
2009-03-26 08:23:48 -06:00
|
|
|
char *sense = dasd_get_sense(&erp->irb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* check for 24 byte sense ERP */
|
|
|
|
if ((erp->function == dasd_3990_erp_bus_out) ||
|
|
|
|
(erp->function == dasd_3990_erp_action_1) ||
|
|
|
|
(erp->function == dasd_3990_erp_action_4)) {
|
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_1(erp);
|
|
|
|
|
2009-12-07 04:51:51 -07:00
|
|
|
} else if (erp->function == dasd_3990_erp_action_1_sec) {
|
|
|
|
erp = dasd_3990_erp_action_1_sec(erp);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (erp->function == dasd_3990_erp_action_5) {
|
|
|
|
|
|
|
|
/* retries have not been successful */
|
|
|
|
/* prepare erp for retry on different channel path */
|
|
|
|
erp = dasd_3990_erp_action_1(erp);
|
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
if (sense && !(sense[2] & DASD_SENSE_BIT_0)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-29 06:58:12 -06:00
|
|
|
/* issue a Diagnostic Control command with an
|
2005-04-16 16:20:36 -06:00
|
|
|
* Inhibit Write subcommand */
|
|
|
|
|
|
|
|
switch (sense[25]) {
|
|
|
|
case 0x17:
|
|
|
|
case 0x57:{ /* controller */
|
|
|
|
erp = dasd_3990_erp_DCTL(erp, 0x20);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 0x18:
|
|
|
|
case 0x58:{ /* channel path */
|
|
|
|
erp = dasd_3990_erp_DCTL(erp, 0x40);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 0x19:
|
|
|
|
case 0x59:{ /* storage director */
|
|
|
|
erp = dasd_3990_erp_DCTL(erp, 0x80);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_WARNING, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"invalid subcommand modifier 0x%x "
|
|
|
|
"for Diagnostic Control Command",
|
|
|
|
sense[25]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check for 32 byte sense ERP */
|
2009-03-26 08:23:48 -06:00
|
|
|
} else if (sense &&
|
|
|
|
((erp->function == dasd_3990_erp_compound_retry) ||
|
|
|
|
(erp->function == dasd_3990_erp_compound_path) ||
|
|
|
|
(erp->function == dasd_3990_erp_compound_code) ||
|
|
|
|
(erp->function == dasd_3990_erp_compound_config))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_compound(erp, sense);
|
|
|
|
|
|
|
|
} else {
|
2009-03-26 08:23:49 -06:00
|
|
|
/*
|
|
|
|
* No retry left and no additional special handling
|
|
|
|
* necessary
|
|
|
|
*/
|
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"ERP %p has run out of retries and failed\n", erp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp->status = DASD_CQR_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_further_erp */
|
|
|
|
|
|
|
|
/*
|
2006-06-29 06:58:12 -06:00
|
|
|
* DASD_3990_ERP_HANDLE_MATCH_ERP
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* An error occurred again and an ERP has been detected which is already
|
2006-06-29 06:58:12 -06:00
|
|
|
* used to handle this error (e.g. retries).
|
2005-04-16 16:20:36 -06:00
|
|
|
* All prior ERP's are asumed to be successful and therefore removed
|
|
|
|
* from queue.
|
2006-06-29 06:58:12 -06:00
|
|
|
* If retry counter of matching erp is already 0, it is checked if further
|
2005-04-16 16:20:36 -06:00
|
|
|
* action is needed (besides retry) or if the ERP has failed.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* erp_head first ERP in ERP-chain
|
|
|
|
* erp ERP that handles the actual error.
|
|
|
|
* (matching erp)
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp modified/additional ERP
|
|
|
|
*/
|
|
|
|
static struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head,
|
|
|
|
struct dasd_ccw_req *erp)
|
|
|
|
{
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = erp_head->startdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct dasd_ccw_req *erp_done = erp_head; /* finished req */
|
|
|
|
struct dasd_ccw_req *erp_free = NULL; /* req to be freed */
|
|
|
|
|
|
|
|
/* loop over successful ERPs and remove them from chanq */
|
|
|
|
while (erp_done != erp) {
|
|
|
|
|
|
|
|
if (erp_done == NULL) /* end of chain reached */
|
|
|
|
panic(PRINTK_HEADER "Programming error in ERP! The "
|
|
|
|
"original request was lost\n");
|
|
|
|
|
|
|
|
/* remove the request from the device queue */
|
2008-01-26 06:11:23 -07:00
|
|
|
list_del(&erp_done->blocklist);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp_free = erp_done;
|
|
|
|
erp_done = erp_done->refers;
|
|
|
|
|
|
|
|
/* free the finished erp request */
|
2008-01-26 06:11:23 -07:00
|
|
|
dasd_free_erp_request(erp_free, erp_free->memdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
} /* end while */
|
|
|
|
|
|
|
|
if (erp->retries > 0) {
|
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
char *sense = dasd_get_sense(&erp->refers->irb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* check for special retries */
|
2009-03-26 08:23:48 -06:00
|
|
|
if (sense && erp->function == dasd_3990_erp_action_4) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_action_4(erp, sense);
|
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
} else if (sense &&
|
|
|
|
erp->function == dasd_3990_erp_action_1B_32) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_update_1B(erp, sense);
|
|
|
|
|
2009-03-26 08:23:48 -06:00
|
|
|
} else if (sense && erp->function == dasd_3990_erp_int_req) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
erp = dasd_3990_erp_int_req(erp);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* simple retry */
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_DEBUG, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"%i retries left for erp %p",
|
|
|
|
erp->retries, erp);
|
|
|
|
|
|
|
|
/* handle the request again... */
|
2008-01-26 06:11:23 -07:00
|
|
|
erp->status = DASD_CQR_FILLED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* no retry left - check for further necessary action */
|
|
|
|
/* if no further actions, handle rest as permanent error */
|
|
|
|
erp = dasd_3990_erp_further_erp(erp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_handle_match_erp */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DASD_3990_ERP_ACTION
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
2008-01-26 06:11:20 -07:00
|
|
|
* control routine for 3990 erp actions.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Has to be called with the queue lock (namely the s390_irq_lock) acquired.
|
|
|
|
*
|
|
|
|
* PARAMETER
|
|
|
|
* cqr failed cqr (either original cqr or already an erp)
|
|
|
|
*
|
|
|
|
* RETURN VALUES
|
|
|
|
* erp erp-pointer to the head of the ERP action chain.
|
|
|
|
* This means:
|
|
|
|
* - either a ptr to an additional ERP cqr or
|
2006-06-29 06:58:12 -06:00
|
|
|
* - the original given cqr (which's status might
|
2005-04-16 16:20:36 -06:00
|
|
|
* be modified)
|
|
|
|
*/
|
|
|
|
struct dasd_ccw_req *
|
|
|
|
dasd_3990_erp_action(struct dasd_ccw_req * cqr)
|
|
|
|
{
|
|
|
|
struct dasd_ccw_req *erp = NULL;
|
2008-01-26 06:11:23 -07:00
|
|
|
struct dasd_device *device = cqr->startdev;
|
2006-12-08 07:54:15 -07:00
|
|
|
struct dasd_ccw_req *temp_erp = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-08 07:54:15 -07:00
|
|
|
if (device->features & DASD_FEATURE_ERPLOG) {
|
|
|
|
/* print current erp_chain */
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"ERP chain at BEGINNING of ERP-ACTION\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
for (temp_erp = cqr;
|
|
|
|
temp_erp != NULL; temp_erp = temp_erp->refers) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"ERP %p (%02x) refers to %p\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
temp_erp, temp_erp->status,
|
|
|
|
temp_erp->refers);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-07 19:09:16 -07:00
|
|
|
/* double-check if current erp/cqr was successful */
|
2009-03-26 08:23:48 -06:00
|
|
|
if ((scsw_cstat(&cqr->irb.scsw) == 0x00) &&
|
|
|
|
(scsw_dstat(&cqr->irb.scsw) ==
|
2008-07-14 01:58:50 -06:00
|
|
|
(DEV_STAT_CHN_END | DEV_STAT_DEV_END))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
DBF_DEV_EVENT(DBF_DEBUG, device,
|
2005-04-16 16:20:36 -06:00
|
|
|
"ERP called for successful request %p"
|
|
|
|
" - NO ERP necessary", cqr);
|
|
|
|
|
|
|
|
cqr->status = DASD_CQR_DONE;
|
|
|
|
|
|
|
|
return cqr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if error happened before */
|
|
|
|
erp = dasd_3990_erp_in_erp(cqr);
|
|
|
|
|
|
|
|
if (erp == NULL) {
|
|
|
|
/* no matching erp found - set up erp */
|
|
|
|
erp = dasd_3990_erp_additional_erp(cqr);
|
2010-04-22 09:17:02 -06:00
|
|
|
if (IS_ERR(erp))
|
|
|
|
return erp;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/* matching erp found - set all leading erp's to DONE */
|
|
|
|
erp = dasd_3990_erp_handle_match_erp(cqr, erp);
|
|
|
|
}
|
|
|
|
|
2006-12-08 07:54:15 -07:00
|
|
|
if (device->features & DASD_FEATURE_ERPLOG) {
|
|
|
|
/* print current erp_chain */
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"ERP chain at END of ERP-ACTION\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
for (temp_erp = erp;
|
|
|
|
temp_erp != NULL; temp_erp = temp_erp->refers) {
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
dev_err(&device->cdev->dev,
|
|
|
|
"ERP %p (%02x) refers to %p\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
temp_erp, temp_erp->status,
|
|
|
|
temp_erp->refers);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-26 06:11:23 -07:00
|
|
|
/* enqueue ERP request if it's a new one */
|
|
|
|
if (list_empty(&erp->blocklist)) {
|
|
|
|
cqr->status = DASD_CQR_IN_ERP;
|
|
|
|
/* add erp request before the cqr */
|
|
|
|
list_add_tail(&erp->blocklist, &cqr->blocklist);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-03-26 08:23:49 -06:00
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return erp;
|
|
|
|
|
|
|
|
} /* end dasd_3990_erp_action */
|