1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Basic HP/COMPAQ MSA 1000 support. This is only needed if your HW cannot be
4 * upgraded.
5 *
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>
9 */
10
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>
17
18 #define HP_SW_NAME "hp_sw"
19
20 #define HP_SW_TIMEOUT (60 * HZ)
21 #define HP_SW_RETRIES 3
22
23 #define HP_SW_PATH_UNINITIALIZED -1
24 #define HP_SW_PATH_ACTIVE 0
25 #define HP_SW_PATH_PASSIVE 1
26
27 struct hp_sw_dh_data {
28 int path_state;
29 int retries;
30 int retry_cnt;
31 struct scsi_device *sdev;
32 };
33
34 static int hp_sw_start_stop(struct hp_sw_dh_data *);
35
36 /*
37 * tur_done - Handle TEST UNIT READY return status
38 * @sdev: sdev the command has been sent to
39 * @errors: blk error code
40 *
41 * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
42 */
tur_done(struct scsi_device * sdev,struct hp_sw_dh_data * h,struct scsi_sense_hdr * sshdr)43 static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
44 struct scsi_sense_hdr *sshdr)
45 {
46 int ret = SCSI_DH_IO;
47
48 switch (sshdr->sense_key) {
49 case NOT_READY:
50 if (sshdr->asc == 0x04 && sshdr->ascq == 2) {
51 /*
52 * LUN not ready - Initialization command required
53 *
54 * This is the passive path
55 */
56 h->path_state = HP_SW_PATH_PASSIVE;
57 ret = SCSI_DH_OK;
58 break;
59 }
60 fallthrough;
61 default:
62 sdev_printk(KERN_WARNING, sdev,
63 "%s: sending tur failed, sense %x/%x/%x\n",
64 HP_SW_NAME, sshdr->sense_key, sshdr->asc,
65 sshdr->ascq);
66 break;
67 }
68 return ret;
69 }
70
71 /*
72 * hp_sw_tur - Send TEST UNIT READY
73 * @sdev: sdev command should be sent to
74 *
75 * Use the TEST UNIT READY command to determine
76 * the path state.
77 */
hp_sw_tur(struct scsi_device * sdev,struct hp_sw_dh_data * h)78 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
79 {
80 unsigned char cmd[6] = { TEST_UNIT_READY };
81 struct scsi_sense_hdr sshdr;
82 int ret, res;
83 blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV |
84 REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
85 struct scsi_failure failure_defs[] = {
86 {
87 .sense = UNIT_ATTENTION,
88 .asc = SCMD_FAILURE_ASC_ANY,
89 .ascq = SCMD_FAILURE_ASCQ_ANY,
90 .allowed = SCMD_FAILURE_NO_LIMIT,
91 .result = SAM_STAT_CHECK_CONDITION,
92 },
93 {}
94 };
95 struct scsi_failures failures = {
96 .failure_definitions = failure_defs,
97 };
98 const struct scsi_exec_args exec_args = {
99 .sshdr = &sshdr,
100 .failures = &failures,
101 };
102
103 res = scsi_execute_cmd(sdev, cmd, opf, NULL, 0, HP_SW_TIMEOUT,
104 HP_SW_RETRIES, &exec_args);
105 if (res > 0 && scsi_sense_valid(&sshdr)) {
106 ret = tur_done(sdev, h, &sshdr);
107 } else if (res == 0) {
108 h->path_state = HP_SW_PATH_ACTIVE;
109 ret = SCSI_DH_OK;
110 } else {
111 sdev_printk(KERN_WARNING, sdev,
112 "%s: sending tur failed with %x\n",
113 HP_SW_NAME, res);
114 ret = SCSI_DH_IO;
115 }
116
117 return ret;
118 }
119
120 /*
121 * hp_sw_start_stop - Send START STOP UNIT command
122 * @sdev: sdev command should be sent to
123 *
124 * Sending START STOP UNIT activates the SP.
125 */
hp_sw_start_stop(struct hp_sw_dh_data * h)126 static int hp_sw_start_stop(struct hp_sw_dh_data *h)
127 {
128 unsigned char cmd[6] = { START_STOP, 0, 0, 0, 1, 0 };
129 struct scsi_sense_hdr sshdr;
130 struct scsi_device *sdev = h->sdev;
131 int res, rc;
132 blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV |
133 REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
134 struct scsi_failure failure_defs[] = {
135 {
136 /*
137 * LUN not ready - manual intervention required
138 *
139 * Switch-over in progress, retry.
140 */
141 .sense = NOT_READY,
142 .asc = 0x04,
143 .ascq = 0x03,
144 .allowed = HP_SW_RETRIES,
145 .result = SAM_STAT_CHECK_CONDITION,
146 },
147 {}
148 };
149 struct scsi_failures failures = {
150 .failure_definitions = failure_defs,
151 };
152 const struct scsi_exec_args exec_args = {
153 .sshdr = &sshdr,
154 .failures = &failures,
155 };
156
157 res = scsi_execute_cmd(sdev, cmd, opf, NULL, 0, HP_SW_TIMEOUT,
158 HP_SW_RETRIES, &exec_args);
159 if (!res) {
160 return SCSI_DH_OK;
161 } else if (res < 0 || !scsi_sense_valid(&sshdr)) {
162 sdev_printk(KERN_WARNING, sdev,
163 "%s: sending start_stop_unit failed, "
164 "no sense available\n", HP_SW_NAME);
165 return SCSI_DH_IO;
166 }
167
168 switch (sshdr.sense_key) {
169 case NOT_READY:
170 if (sshdr.asc == 0x04 && sshdr.ascq == 3) {
171 rc = SCSI_DH_RETRY;
172 break;
173 }
174 fallthrough;
175 default:
176 sdev_printk(KERN_WARNING, sdev,
177 "%s: sending start_stop_unit failed, "
178 "sense %x/%x/%x\n", HP_SW_NAME,
179 sshdr.sense_key, sshdr.asc, sshdr.ascq);
180 rc = SCSI_DH_IO;
181 }
182
183 return rc;
184 }
185
hp_sw_prep_fn(struct scsi_device * sdev,struct request * req)186 static blk_status_t hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
187 {
188 struct hp_sw_dh_data *h = sdev->handler_data;
189
190 if (h->path_state != HP_SW_PATH_ACTIVE) {
191 req->rq_flags |= RQF_QUIET;
192 return BLK_STS_IOERR;
193 }
194
195 return BLK_STS_OK;
196 }
197
198 /*
199 * hp_sw_activate - Activate a path
200 * @sdev: sdev on the path to be activated
201 *
202 * The HP Active/Passive firmware is pretty simple;
203 * the passive path reports NOT READY with sense codes
204 * 0x04/0x02; a START STOP UNIT command will then
205 * activate the passive path (and deactivate the
206 * previously active one).
207 */
hp_sw_activate(struct scsi_device * sdev,activate_complete fn,void * data)208 static int hp_sw_activate(struct scsi_device *sdev,
209 activate_complete fn, void *data)
210 {
211 int ret = SCSI_DH_OK;
212 struct hp_sw_dh_data *h = sdev->handler_data;
213
214 ret = hp_sw_tur(sdev, h);
215
216 if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE)
217 ret = hp_sw_start_stop(h);
218
219 if (fn)
220 fn(data, ret);
221 return 0;
222 }
223
hp_sw_bus_attach(struct scsi_device * sdev)224 static int hp_sw_bus_attach(struct scsi_device *sdev)
225 {
226 struct hp_sw_dh_data *h;
227 int ret;
228
229 h = kzalloc(sizeof(*h), GFP_KERNEL);
230 if (!h)
231 return SCSI_DH_NOMEM;
232 h->path_state = HP_SW_PATH_UNINITIALIZED;
233 h->retries = HP_SW_RETRIES;
234 h->sdev = sdev;
235
236 ret = hp_sw_tur(sdev, h);
237 if (ret != SCSI_DH_OK)
238 goto failed;
239 if (h->path_state == HP_SW_PATH_UNINITIALIZED) {
240 ret = SCSI_DH_NOSYS;
241 goto failed;
242 }
243
244 sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
245 HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
246 "active":"passive");
247
248 sdev->handler_data = h;
249 return SCSI_DH_OK;
250 failed:
251 kfree(h);
252 return ret;
253 }
254
hp_sw_bus_detach(struct scsi_device * sdev)255 static void hp_sw_bus_detach( struct scsi_device *sdev )
256 {
257 kfree(sdev->handler_data);
258 sdev->handler_data = NULL;
259 }
260
261 static struct scsi_device_handler hp_sw_dh = {
262 .name = HP_SW_NAME,
263 .module = THIS_MODULE,
264 .attach = hp_sw_bus_attach,
265 .detach = hp_sw_bus_detach,
266 .activate = hp_sw_activate,
267 .prep_fn = hp_sw_prep_fn,
268 };
269
hp_sw_init(void)270 static int __init hp_sw_init(void)
271 {
272 return scsi_register_device_handler(&hp_sw_dh);
273 }
274
hp_sw_exit(void)275 static void __exit hp_sw_exit(void)
276 {
277 scsi_unregister_device_handler(&hp_sw_dh);
278 }
279
280 module_init(hp_sw_init);
281 module_exit(hp_sw_exit);
282
283 MODULE_DESCRIPTION("HP Active/Passive driver");
284 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
285 MODULE_LICENSE("GPL");
286