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 	unsigned char sense[SCSI_SENSE_BUFFERSIZE];
42 	int path_state;
43 	int retries;
44 	int retry_cnt;
45 	struct scsi_device *sdev;
46 	activate_complete	callback_fn;
47 	void			*callback_data;
48 };
49 
50 static int hp_sw_start_stop(struct hp_sw_dh_data *);
51 
52 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
53 {
54 	struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
55 	BUG_ON(scsi_dh_data == NULL);
56 	return ((struct hp_sw_dh_data *) scsi_dh_data->buf);
57 }
58 
59 /*
60  * tur_done - Handle TEST UNIT READY return status
61  * @sdev: sdev the command has been sent to
62  * @errors: blk error code
63  *
64  * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
65  */
66 static int tur_done(struct scsi_device *sdev, unsigned char *sense)
67 {
68 	struct scsi_sense_hdr sshdr;
69 	int ret;
70 
71 	ret = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
72 	if (!ret) {
73 		sdev_printk(KERN_WARNING, sdev,
74 			    "%s: sending tur failed, no sense available\n",
75 			    HP_SW_NAME);
76 		ret = SCSI_DH_IO;
77 		goto done;
78 	}
79 	switch (sshdr.sense_key) {
80 	case UNIT_ATTENTION:
81 		ret = SCSI_DH_IMM_RETRY;
82 		break;
83 	case NOT_READY:
84 		if ((sshdr.asc == 0x04) && (sshdr.ascq == 2)) {
85 			/*
86 			 * LUN not ready - Initialization command required
87 			 *
88 			 * This is the passive path
89 			 */
90 			ret = SCSI_DH_DEV_OFFLINED;
91 			break;
92 		}
93 		/* Fallthrough */
94 	default:
95 		sdev_printk(KERN_WARNING, sdev,
96 			   "%s: sending tur failed, sense %x/%x/%x\n",
97 			   HP_SW_NAME, sshdr.sense_key, sshdr.asc,
98 			   sshdr.ascq);
99 		break;
100 	}
101 
102 done:
103 	return ret;
104 }
105 
106 /*
107  * hp_sw_tur - Send TEST UNIT READY
108  * @sdev: sdev command should be sent to
109  *
110  * Use the TEST UNIT READY command to determine
111  * the path state.
112  */
113 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
114 {
115 	struct request *req;
116 	int ret;
117 
118 retry:
119 	req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
120 	if (!req)
121 		return SCSI_DH_RES_TEMP_UNAVAIL;
122 
123 	blk_rq_set_block_pc(req);
124 	req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
125 			  REQ_FAILFAST_DRIVER;
126 	req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY);
127 	req->cmd[0] = TEST_UNIT_READY;
128 	req->timeout = HP_SW_TIMEOUT;
129 	req->sense = h->sense;
130 	memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
131 	req->sense_len = 0;
132 
133 	ret = blk_execute_rq(req->q, NULL, req, 1);
134 	if (ret == -EIO) {
135 		if (req->sense_len > 0) {
136 			ret = tur_done(sdev, h->sense);
137 		} else {
138 			sdev_printk(KERN_WARNING, sdev,
139 				    "%s: sending tur failed with %x\n",
140 				    HP_SW_NAME, req->errors);
141 			ret = SCSI_DH_IO;
142 		}
143 	} else {
144 		h->path_state = HP_SW_PATH_ACTIVE;
145 		ret = SCSI_DH_OK;
146 	}
147 	if (ret == SCSI_DH_IMM_RETRY) {
148 		blk_put_request(req);
149 		goto retry;
150 	}
151 	if (ret == SCSI_DH_DEV_OFFLINED) {
152 		h->path_state = HP_SW_PATH_PASSIVE;
153 		ret = SCSI_DH_OK;
154 	}
155 
156 	blk_put_request(req);
157 
158 	return ret;
159 }
160 
161 /*
162  * start_done - Handle START STOP UNIT return status
163  * @sdev: sdev the command has been sent to
164  * @errors: blk error code
165  */
166 static int start_done(struct scsi_device *sdev, unsigned char *sense)
167 {
168 	struct scsi_sense_hdr sshdr;
169 	int rc;
170 
171 	rc = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
172 	if (!rc) {
173 		sdev_printk(KERN_WARNING, sdev,
174 			    "%s: sending start_stop_unit failed, "
175 			    "no sense available\n",
176 			    HP_SW_NAME);
177 		return SCSI_DH_IO;
178 	}
179 	switch (sshdr.sense_key) {
180 	case NOT_READY:
181 		if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
182 			/*
183 			 * LUN not ready - manual intervention required
184 			 *
185 			 * Switch-over in progress, retry.
186 			 */
187 			rc = SCSI_DH_RETRY;
188 			break;
189 		}
190 		/* fall through */
191 	default:
192 		sdev_printk(KERN_WARNING, sdev,
193 			   "%s: sending start_stop_unit failed, sense %x/%x/%x\n",
194 			   HP_SW_NAME, sshdr.sense_key, sshdr.asc,
195 			   sshdr.ascq);
196 		rc = SCSI_DH_IO;
197 	}
198 
199 	return rc;
200 }
201 
202 static void start_stop_endio(struct request *req, int error)
203 {
204 	struct hp_sw_dh_data *h = req->end_io_data;
205 	unsigned err = SCSI_DH_OK;
206 
207 	if (error || host_byte(req->errors) != DID_OK ||
208 			msg_byte(req->errors) != COMMAND_COMPLETE) {
209 		sdev_printk(KERN_WARNING, h->sdev,
210 			    "%s: sending start_stop_unit failed with %x\n",
211 			    HP_SW_NAME, req->errors);
212 		err = SCSI_DH_IO;
213 		goto done;
214 	}
215 
216 	if (req->sense_len > 0) {
217 		err = start_done(h->sdev, h->sense);
218 		if (err == SCSI_DH_RETRY) {
219 			err = SCSI_DH_IO;
220 			if (--h->retry_cnt) {
221 				blk_put_request(req);
222 				err = hp_sw_start_stop(h);
223 				if (err == SCSI_DH_OK)
224 					return;
225 			}
226 		}
227 	}
228 done:
229 	req->end_io_data = NULL;
230 	__blk_put_request(req->q, req);
231 	if (h->callback_fn) {
232 		h->callback_fn(h->callback_data, err);
233 		h->callback_fn = h->callback_data = NULL;
234 	}
235 	return;
236 
237 }
238 
239 /*
240  * hp_sw_start_stop - Send START STOP UNIT command
241  * @sdev: sdev command should be sent to
242  *
243  * Sending START STOP UNIT activates the SP.
244  */
245 static int hp_sw_start_stop(struct hp_sw_dh_data *h)
246 {
247 	struct request *req;
248 
249 	req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
250 	if (!req)
251 		return SCSI_DH_RES_TEMP_UNAVAIL;
252 
253 	blk_rq_set_block_pc(req);
254 	req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
255 			  REQ_FAILFAST_DRIVER;
256 	req->cmd_len = COMMAND_SIZE(START_STOP);
257 	req->cmd[0] = START_STOP;
258 	req->cmd[4] = 1;	/* Start spin cycle */
259 	req->timeout = HP_SW_TIMEOUT;
260 	req->sense = h->sense;
261 	memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
262 	req->sense_len = 0;
263 	req->end_io_data = h;
264 
265 	blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
266 	return SCSI_DH_OK;
267 }
268 
269 static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
270 {
271 	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
272 	int ret = BLKPREP_OK;
273 
274 	if (h->path_state != HP_SW_PATH_ACTIVE) {
275 		ret = BLKPREP_KILL;
276 		req->cmd_flags |= REQ_QUIET;
277 	}
278 	return ret;
279 
280 }
281 
282 /*
283  * hp_sw_activate - Activate a path
284  * @sdev: sdev on the path to be activated
285  *
286  * The HP Active/Passive firmware is pretty simple;
287  * the passive path reports NOT READY with sense codes
288  * 0x04/0x02; a START STOP UNIT command will then
289  * activate the passive path (and deactivate the
290  * previously active one).
291  */
292 static int hp_sw_activate(struct scsi_device *sdev,
293 				activate_complete fn, void *data)
294 {
295 	int ret = SCSI_DH_OK;
296 	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
297 
298 	ret = hp_sw_tur(sdev, h);
299 
300 	if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
301 		h->retry_cnt = h->retries;
302 		h->callback_fn = fn;
303 		h->callback_data = data;
304 		ret = hp_sw_start_stop(h);
305 		if (ret == SCSI_DH_OK)
306 			return 0;
307 		h->callback_fn = h->callback_data = NULL;
308 	}
309 
310 	if (fn)
311 		fn(data, ret);
312 	return 0;
313 }
314 
315 static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
316 	{"COMPAQ", "MSA1000 VOLUME"},
317 	{"COMPAQ", "HSV110"},
318 	{"HP", "HSV100"},
319 	{"DEC", "HSG80"},
320 	{NULL, NULL},
321 };
322 
323 static bool hp_sw_match(struct scsi_device *sdev)
324 {
325 	int i;
326 
327 	if (scsi_device_tpgs(sdev))
328 		return false;
329 
330 	for (i = 0; hp_sw_dh_data_list[i].vendor; i++) {
331 		if (!strncmp(sdev->vendor, hp_sw_dh_data_list[i].vendor,
332 			strlen(hp_sw_dh_data_list[i].vendor)) &&
333 		    !strncmp(sdev->model, hp_sw_dh_data_list[i].model,
334 			strlen(hp_sw_dh_data_list[i].model))) {
335 			return true;
336 		}
337 	}
338 	return false;
339 }
340 
341 static int hp_sw_bus_attach(struct scsi_device *sdev);
342 static void hp_sw_bus_detach(struct scsi_device *sdev);
343 
344 static struct scsi_device_handler hp_sw_dh = {
345 	.name		= HP_SW_NAME,
346 	.module		= THIS_MODULE,
347 	.devlist	= hp_sw_dh_data_list,
348 	.attach		= hp_sw_bus_attach,
349 	.detach		= hp_sw_bus_detach,
350 	.activate	= hp_sw_activate,
351 	.prep_fn	= hp_sw_prep_fn,
352 	.match		= hp_sw_match,
353 };
354 
355 static int hp_sw_bus_attach(struct scsi_device *sdev)
356 {
357 	struct scsi_dh_data *scsi_dh_data;
358 	struct hp_sw_dh_data *h;
359 	unsigned long flags;
360 	int ret;
361 
362 	scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
363 			       + sizeof(*h) , GFP_KERNEL);
364 	if (!scsi_dh_data) {
365 		sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
366 			    HP_SW_NAME);
367 		return 0;
368 	}
369 
370 	scsi_dh_data->scsi_dh = &hp_sw_dh;
371 	h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
372 	h->path_state = HP_SW_PATH_UNINITIALIZED;
373 	h->retries = HP_SW_RETRIES;
374 	h->sdev = sdev;
375 
376 	ret = hp_sw_tur(sdev, h);
377 	if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
378 		goto failed;
379 
380 	if (!try_module_get(THIS_MODULE))
381 		goto failed;
382 
383 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
384 	sdev->scsi_dh_data = scsi_dh_data;
385 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
386 
387 	sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
388 		    HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
389 		    "active":"passive");
390 
391 	return 0;
392 
393 failed:
394 	kfree(scsi_dh_data);
395 	sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
396 		    HP_SW_NAME);
397 	return -EINVAL;
398 }
399 
400 static void hp_sw_bus_detach( struct scsi_device *sdev )
401 {
402 	struct scsi_dh_data *scsi_dh_data;
403 	unsigned long flags;
404 
405 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
406 	scsi_dh_data = sdev->scsi_dh_data;
407 	sdev->scsi_dh_data = NULL;
408 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
409 	module_put(THIS_MODULE);
410 
411 	sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", HP_SW_NAME);
412 
413 	kfree(scsi_dh_data);
414 }
415 
416 static int __init hp_sw_init(void)
417 {
418 	return scsi_register_device_handler(&hp_sw_dh);
419 }
420 
421 static void __exit hp_sw_exit(void)
422 {
423 	scsi_unregister_device_handler(&hp_sw_dh);
424 }
425 
426 module_init(hp_sw_init);
427 module_exit(hp_sw_exit);
428 
429 MODULE_DESCRIPTION("HP Active/Passive driver");
430 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
431 MODULE_LICENSE("GPL");
432