1 /*
2  * Basic HP/COMPAQ MSA 1000 support. This is only needed if your HW cannot be
3  * upgraded.
4  *
5  * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
6  * Copyright (C) 2006 Mike Christie
7  * Copyright (C) 2008 Hannes Reinecke <hare@suse.de>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2, or (at your option)
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; see the file COPYING.  If not, write to
21  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23 
24 #include <linux/slab.h>
25 #include <linux/module.h>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_dbg.h>
28 #include <scsi/scsi_eh.h>
29 #include <scsi/scsi_dh.h>
30 
31 #define HP_SW_NAME			"hp_sw"
32 
33 #define HP_SW_TIMEOUT			(60 * HZ)
34 #define HP_SW_RETRIES			3
35 
36 #define HP_SW_PATH_UNINITIALIZED	-1
37 #define HP_SW_PATH_ACTIVE		0
38 #define HP_SW_PATH_PASSIVE		1
39 
40 struct hp_sw_dh_data {
41 	struct scsi_dh_data dh_data;
42 	unsigned char sense[SCSI_SENSE_BUFFERSIZE];
43 	int path_state;
44 	int retries;
45 	int retry_cnt;
46 	struct scsi_device *sdev;
47 	activate_complete	callback_fn;
48 	void			*callback_data;
49 };
50 
51 static int hp_sw_start_stop(struct hp_sw_dh_data *);
52 
53 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
54 {
55 	return container_of(sdev->scsi_dh_data, struct hp_sw_dh_data, dh_data);
56 }
57 
58 /*
59  * tur_done - Handle TEST UNIT READY return status
60  * @sdev: sdev the command has been sent to
61  * @errors: blk error code
62  *
63  * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
64  */
65 static int tur_done(struct scsi_device *sdev, unsigned char *sense)
66 {
67 	struct scsi_sense_hdr sshdr;
68 	int ret;
69 
70 	ret = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
71 	if (!ret) {
72 		sdev_printk(KERN_WARNING, sdev,
73 			    "%s: sending tur failed, no sense available\n",
74 			    HP_SW_NAME);
75 		ret = SCSI_DH_IO;
76 		goto done;
77 	}
78 	switch (sshdr.sense_key) {
79 	case UNIT_ATTENTION:
80 		ret = SCSI_DH_IMM_RETRY;
81 		break;
82 	case NOT_READY:
83 		if ((sshdr.asc == 0x04) && (sshdr.ascq == 2)) {
84 			/*
85 			 * LUN not ready - Initialization command required
86 			 *
87 			 * This is the passive path
88 			 */
89 			ret = SCSI_DH_DEV_OFFLINED;
90 			break;
91 		}
92 		/* Fallthrough */
93 	default:
94 		sdev_printk(KERN_WARNING, sdev,
95 			   "%s: sending tur failed, sense %x/%x/%x\n",
96 			   HP_SW_NAME, sshdr.sense_key, sshdr.asc,
97 			   sshdr.ascq);
98 		break;
99 	}
100 
101 done:
102 	return ret;
103 }
104 
105 /*
106  * hp_sw_tur - Send TEST UNIT READY
107  * @sdev: sdev command should be sent to
108  *
109  * Use the TEST UNIT READY command to determine
110  * the path state.
111  */
112 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
113 {
114 	struct request *req;
115 	int ret;
116 
117 retry:
118 	req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
119 	if (IS_ERR(req))
120 		return SCSI_DH_RES_TEMP_UNAVAIL;
121 
122 	blk_rq_set_block_pc(req);
123 	req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
124 			  REQ_FAILFAST_DRIVER;
125 	req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY);
126 	req->cmd[0] = TEST_UNIT_READY;
127 	req->timeout = HP_SW_TIMEOUT;
128 	req->sense = h->sense;
129 	memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
130 	req->sense_len = 0;
131 
132 	ret = blk_execute_rq(req->q, NULL, req, 1);
133 	if (ret == -EIO) {
134 		if (req->sense_len > 0) {
135 			ret = tur_done(sdev, h->sense);
136 		} else {
137 			sdev_printk(KERN_WARNING, sdev,
138 				    "%s: sending tur failed with %x\n",
139 				    HP_SW_NAME, req->errors);
140 			ret = SCSI_DH_IO;
141 		}
142 	} else {
143 		h->path_state = HP_SW_PATH_ACTIVE;
144 		ret = SCSI_DH_OK;
145 	}
146 	if (ret == SCSI_DH_IMM_RETRY) {
147 		blk_put_request(req);
148 		goto retry;
149 	}
150 	if (ret == SCSI_DH_DEV_OFFLINED) {
151 		h->path_state = HP_SW_PATH_PASSIVE;
152 		ret = SCSI_DH_OK;
153 	}
154 
155 	blk_put_request(req);
156 
157 	return ret;
158 }
159 
160 /*
161  * start_done - Handle START STOP UNIT return status
162  * @sdev: sdev the command has been sent to
163  * @errors: blk error code
164  */
165 static int start_done(struct scsi_device *sdev, unsigned char *sense)
166 {
167 	struct scsi_sense_hdr sshdr;
168 	int rc;
169 
170 	rc = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
171 	if (!rc) {
172 		sdev_printk(KERN_WARNING, sdev,
173 			    "%s: sending start_stop_unit failed, "
174 			    "no sense available\n",
175 			    HP_SW_NAME);
176 		return SCSI_DH_IO;
177 	}
178 	switch (sshdr.sense_key) {
179 	case NOT_READY:
180 		if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
181 			/*
182 			 * LUN not ready - manual intervention required
183 			 *
184 			 * Switch-over in progress, retry.
185 			 */
186 			rc = SCSI_DH_RETRY;
187 			break;
188 		}
189 		/* fall through */
190 	default:
191 		sdev_printk(KERN_WARNING, sdev,
192 			   "%s: sending start_stop_unit failed, sense %x/%x/%x\n",
193 			   HP_SW_NAME, sshdr.sense_key, sshdr.asc,
194 			   sshdr.ascq);
195 		rc = SCSI_DH_IO;
196 	}
197 
198 	return rc;
199 }
200 
201 static void start_stop_endio(struct request *req, int error)
202 {
203 	struct hp_sw_dh_data *h = req->end_io_data;
204 	unsigned err = SCSI_DH_OK;
205 
206 	if (error || host_byte(req->errors) != DID_OK ||
207 			msg_byte(req->errors) != COMMAND_COMPLETE) {
208 		sdev_printk(KERN_WARNING, h->sdev,
209 			    "%s: sending start_stop_unit failed with %x\n",
210 			    HP_SW_NAME, req->errors);
211 		err = SCSI_DH_IO;
212 		goto done;
213 	}
214 
215 	if (req->sense_len > 0) {
216 		err = start_done(h->sdev, h->sense);
217 		if (err == SCSI_DH_RETRY) {
218 			err = SCSI_DH_IO;
219 			if (--h->retry_cnt) {
220 				blk_put_request(req);
221 				err = hp_sw_start_stop(h);
222 				if (err == SCSI_DH_OK)
223 					return;
224 			}
225 		}
226 	}
227 done:
228 	req->end_io_data = NULL;
229 	__blk_put_request(req->q, req);
230 	if (h->callback_fn) {
231 		h->callback_fn(h->callback_data, err);
232 		h->callback_fn = h->callback_data = NULL;
233 	}
234 	return;
235 
236 }
237 
238 /*
239  * hp_sw_start_stop - Send START STOP UNIT command
240  * @sdev: sdev command should be sent to
241  *
242  * Sending START STOP UNIT activates the SP.
243  */
244 static int hp_sw_start_stop(struct hp_sw_dh_data *h)
245 {
246 	struct request *req;
247 
248 	req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
249 	if (IS_ERR(req))
250 		return SCSI_DH_RES_TEMP_UNAVAIL;
251 
252 	blk_rq_set_block_pc(req);
253 	req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
254 			  REQ_FAILFAST_DRIVER;
255 	req->cmd_len = COMMAND_SIZE(START_STOP);
256 	req->cmd[0] = START_STOP;
257 	req->cmd[4] = 1;	/* Start spin cycle */
258 	req->timeout = HP_SW_TIMEOUT;
259 	req->sense = h->sense;
260 	memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
261 	req->sense_len = 0;
262 	req->end_io_data = h;
263 
264 	blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
265 	return SCSI_DH_OK;
266 }
267 
268 static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
269 {
270 	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
271 	int ret = BLKPREP_OK;
272 
273 	if (h->path_state != HP_SW_PATH_ACTIVE) {
274 		ret = BLKPREP_KILL;
275 		req->cmd_flags |= REQ_QUIET;
276 	}
277 	return ret;
278 
279 }
280 
281 /*
282  * hp_sw_activate - Activate a path
283  * @sdev: sdev on the path to be activated
284  *
285  * The HP Active/Passive firmware is pretty simple;
286  * the passive path reports NOT READY with sense codes
287  * 0x04/0x02; a START STOP UNIT command will then
288  * activate the passive path (and deactivate the
289  * previously active one).
290  */
291 static int hp_sw_activate(struct scsi_device *sdev,
292 				activate_complete fn, void *data)
293 {
294 	int ret = SCSI_DH_OK;
295 	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
296 
297 	ret = hp_sw_tur(sdev, h);
298 
299 	if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
300 		h->retry_cnt = h->retries;
301 		h->callback_fn = fn;
302 		h->callback_data = data;
303 		ret = hp_sw_start_stop(h);
304 		if (ret == SCSI_DH_OK)
305 			return 0;
306 		h->callback_fn = h->callback_data = NULL;
307 	}
308 
309 	if (fn)
310 		fn(data, ret);
311 	return 0;
312 }
313 
314 static const struct {
315 	char *vendor;
316 	char *model;
317 } hp_sw_dh_data_list[] = {
318 	{"COMPAQ", "MSA1000 VOLUME"},
319 	{"COMPAQ", "HSV110"},
320 	{"HP", "HSV100"},
321 	{"DEC", "HSG80"},
322 	{NULL, NULL},
323 };
324 
325 static bool hp_sw_match(struct scsi_device *sdev)
326 {
327 	int i;
328 
329 	if (scsi_device_tpgs(sdev))
330 		return false;
331 
332 	for (i = 0; hp_sw_dh_data_list[i].vendor; i++) {
333 		if (!strncmp(sdev->vendor, hp_sw_dh_data_list[i].vendor,
334 			strlen(hp_sw_dh_data_list[i].vendor)) &&
335 		    !strncmp(sdev->model, hp_sw_dh_data_list[i].model,
336 			strlen(hp_sw_dh_data_list[i].model))) {
337 			return true;
338 		}
339 	}
340 	return false;
341 }
342 
343 static struct scsi_dh_data *hp_sw_bus_attach(struct scsi_device *sdev)
344 {
345 	struct hp_sw_dh_data *h;
346 	int ret;
347 
348 	h = kzalloc(sizeof(*h), GFP_KERNEL);
349 	if (!h)
350 		return ERR_PTR(-ENOMEM);
351 	h->path_state = HP_SW_PATH_UNINITIALIZED;
352 	h->retries = HP_SW_RETRIES;
353 	h->sdev = sdev;
354 
355 	ret = hp_sw_tur(sdev, h);
356 	if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
357 		goto failed;
358 
359 	sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
360 		    HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
361 		    "active":"passive");
362 	return &h->dh_data;
363 failed:
364 	kfree(h);
365 	return ERR_PTR(-EINVAL);
366 }
367 
368 static void hp_sw_bus_detach( struct scsi_device *sdev )
369 {
370 	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
371 
372 	kfree(h);
373 }
374 
375 static struct scsi_device_handler hp_sw_dh = {
376 	.name		= HP_SW_NAME,
377 	.module		= THIS_MODULE,
378 	.attach		= hp_sw_bus_attach,
379 	.detach		= hp_sw_bus_detach,
380 	.activate	= hp_sw_activate,
381 	.prep_fn	= hp_sw_prep_fn,
382 	.match		= hp_sw_match,
383 };
384 
385 static int __init hp_sw_init(void)
386 {
387 	return scsi_register_device_handler(&hp_sw_dh);
388 }
389 
390 static void __exit hp_sw_exit(void)
391 {
392 	scsi_unregister_device_handler(&hp_sw_dh);
393 }
394 
395 module_init(hp_sw_init);
396 module_exit(hp_sw_exit);
397 
398 MODULE_DESCRIPTION("HP Active/Passive driver");
399 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
400 MODULE_LICENSE("GPL");
401