1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Basic HP/COMPAQ MSA 1000 support. This is only needed if your HW cannot be
6 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.
7 * Copyright (C) 2006 Mike Christie
8 * Copyright (C) 2008 Hannes Reinecke <hare@suse.de>
11 #include <linux/slab.h>
12 #include <linux/module.h>
13 #include <scsi/scsi.h>
14 #include <scsi/scsi_dbg.h>
15 #include <scsi/scsi_eh.h>
16 #include <scsi/scsi_dh.h>
18 #define HP_SW_NAME "hp_sw"
20 #define HP_SW_TIMEOUT (60 * HZ)
21 #define HP_SW_RETRIES 3
23 #define HP_SW_PATH_UNINITIALIZED -1
24 #define HP_SW_PATH_ACTIVE 0
25 #define HP_SW_PATH_PASSIVE 1
27 struct hp_sw_dh_data {
31 struct scsi_device *sdev;
34 static int hp_sw_start_stop(struct hp_sw_dh_data *);
37 * tur_done - Handle TEST UNIT READY return status
38 * @sdev: sdev the command has been sent to
39 * @errors: blk error code
41 * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
43 static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
44 struct scsi_sense_hdr *sshdr)
48 switch (sshdr->sense_key) {
50 ret = SCSI_DH_IMM_RETRY;
53 if (sshdr->asc == 0x04 && sshdr->ascq == 2) {
55 * LUN not ready - Initialization command required
57 * This is the passive path
59 h->path_state = HP_SW_PATH_PASSIVE;
65 sdev_printk(KERN_WARNING, sdev,
66 "%s: sending tur failed, sense %x/%x/%x\n",
67 HP_SW_NAME, sshdr->sense_key, sshdr->asc,
75 * hp_sw_tur - Send TEST UNIT READY
76 * @sdev: sdev command should be sent to
78 * Use the TEST UNIT READY command to determine
81 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
83 unsigned char cmd[6] = { TEST_UNIT_READY };
84 struct scsi_sense_hdr sshdr;
85 int ret = SCSI_DH_OK, res;
86 blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV |
87 REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
88 const struct scsi_exec_args exec_args = {
93 res = scsi_execute_cmd(sdev, cmd, opf, NULL, 0, HP_SW_TIMEOUT,
94 HP_SW_RETRIES, &exec_args);
96 if (scsi_sense_valid(&sshdr))
97 ret = tur_done(sdev, h, &sshdr);
99 sdev_printk(KERN_WARNING, sdev,
100 "%s: sending tur failed with %x\n",
105 h->path_state = HP_SW_PATH_ACTIVE;
108 if (ret == SCSI_DH_IMM_RETRY)
115 * hp_sw_start_stop - Send START STOP UNIT command
116 * @sdev: sdev command should be sent to
118 * Sending START STOP UNIT activates the SP.
120 static int hp_sw_start_stop(struct hp_sw_dh_data *h)
122 unsigned char cmd[6] = { START_STOP, 0, 0, 0, 1, 0 };
123 struct scsi_sense_hdr sshdr;
124 struct scsi_device *sdev = h->sdev;
125 int res, rc = SCSI_DH_OK;
126 int retry_cnt = HP_SW_RETRIES;
127 blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV |
128 REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
129 const struct scsi_exec_args exec_args = {
134 res = scsi_execute_cmd(sdev, cmd, opf, NULL, 0, HP_SW_TIMEOUT,
135 HP_SW_RETRIES, &exec_args);
137 if (!scsi_sense_valid(&sshdr)) {
138 sdev_printk(KERN_WARNING, sdev,
139 "%s: sending start_stop_unit failed, "
140 "no sense available\n", HP_SW_NAME);
143 switch (sshdr.sense_key) {
145 if (sshdr.asc == 0x04 && sshdr.ascq == 3) {
147 * LUN not ready - manual intervention required
149 * Switch-over in progress, retry.
158 sdev_printk(KERN_WARNING, sdev,
159 "%s: sending start_stop_unit failed, "
160 "sense %x/%x/%x\n", HP_SW_NAME,
161 sshdr.sense_key, sshdr.asc, sshdr.ascq);
168 static blk_status_t hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
170 struct hp_sw_dh_data *h = sdev->handler_data;
172 if (h->path_state != HP_SW_PATH_ACTIVE) {
173 req->rq_flags |= RQF_QUIET;
174 return BLK_STS_IOERR;
181 * hp_sw_activate - Activate a path
182 * @sdev: sdev on the path to be activated
184 * The HP Active/Passive firmware is pretty simple;
185 * the passive path reports NOT READY with sense codes
186 * 0x04/0x02; a START STOP UNIT command will then
187 * activate the passive path (and deactivate the
188 * previously active one).
190 static int hp_sw_activate(struct scsi_device *sdev,
191 activate_complete fn, void *data)
193 int ret = SCSI_DH_OK;
194 struct hp_sw_dh_data *h = sdev->handler_data;
196 ret = hp_sw_tur(sdev, h);
198 if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE)
199 ret = hp_sw_start_stop(h);
206 static int hp_sw_bus_attach(struct scsi_device *sdev)
208 struct hp_sw_dh_data *h;
211 h = kzalloc(sizeof(*h), GFP_KERNEL);
213 return SCSI_DH_NOMEM;
214 h->path_state = HP_SW_PATH_UNINITIALIZED;
215 h->retries = HP_SW_RETRIES;
218 ret = hp_sw_tur(sdev, h);
219 if (ret != SCSI_DH_OK)
221 if (h->path_state == HP_SW_PATH_UNINITIALIZED) {
226 sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
227 HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
230 sdev->handler_data = h;
237 static void hp_sw_bus_detach( struct scsi_device *sdev )
239 kfree(sdev->handler_data);
240 sdev->handler_data = NULL;
243 static struct scsi_device_handler hp_sw_dh = {
245 .module = THIS_MODULE,
246 .attach = hp_sw_bus_attach,
247 .detach = hp_sw_bus_detach,
248 .activate = hp_sw_activate,
249 .prep_fn = hp_sw_prep_fn,
252 static int __init hp_sw_init(void)
254 return scsi_register_device_handler(&hp_sw_dh);
257 static void __exit hp_sw_exit(void)
259 scsi_unregister_device_handler(&hp_sw_dh);
262 module_init(hp_sw_init);
263 module_exit(hp_sw_exit);
265 MODULE_DESCRIPTION("HP Active/Passive driver");
266 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
267 MODULE_LICENSE("GPL");