PageRenderTime 50ms CodeModel.GetById 15ms app.highlight 29ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/scsi/device_handler/scsi_dh_hp_sw.c

https://bitbucket.org/abioy/linux
C | 410 lines | 287 code | 54 blank | 69 comment | 51 complexity | 82f2bc2a0ce2e96df2d6e5b9ecf17030 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0
  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 <scsi/scsi.h>
 26#include <scsi/scsi_dbg.h>
 27#include <scsi/scsi_eh.h>
 28#include <scsi/scsi_dh.h>
 29
 30#define HP_SW_NAME			"hp_sw"
 31
 32#define HP_SW_TIMEOUT			(60 * HZ)
 33#define HP_SW_RETRIES			3
 34
 35#define HP_SW_PATH_UNINITIALIZED	-1
 36#define HP_SW_PATH_ACTIVE		0
 37#define HP_SW_PATH_PASSIVE		1
 38
 39struct hp_sw_dh_data {
 40	unsigned char sense[SCSI_SENSE_BUFFERSIZE];
 41	int path_state;
 42	int retries;
 43	int retry_cnt;
 44	struct scsi_device *sdev;
 45	activate_complete	callback_fn;
 46	void			*callback_data;
 47};
 48
 49static int hp_sw_start_stop(struct hp_sw_dh_data *);
 50
 51static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
 52{
 53	struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
 54	BUG_ON(scsi_dh_data == NULL);
 55	return ((struct hp_sw_dh_data *) scsi_dh_data->buf);
 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 */
 65static 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
101done:
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 */
112static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
113{
114	struct request *req;
115	int ret;
116
117retry:
118	req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
119	if (!req)
120		return SCSI_DH_RES_TEMP_UNAVAIL;
121
122	req->cmd_type = REQ_TYPE_BLOCK_PC;
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 */
165static 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
201static 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	}
227done:
228	blk_put_request(req);
229	if (h->callback_fn) {
230		h->callback_fn(h->callback_data, err);
231		h->callback_fn = h->callback_data = NULL;
232	}
233	return;
234
235}
236
237/*
238 * hp_sw_start_stop - Send START STOP UNIT command
239 * @sdev: sdev command should be sent to
240 *
241 * Sending START STOP UNIT activates the SP.
242 */
243static int hp_sw_start_stop(struct hp_sw_dh_data *h)
244{
245	struct request *req;
246
247	req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
248	if (!req)
249		return SCSI_DH_RES_TEMP_UNAVAIL;
250
251	req->cmd_type = REQ_TYPE_BLOCK_PC;
252	req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
253			  REQ_FAILFAST_DRIVER;
254	req->cmd_len = COMMAND_SIZE(START_STOP);
255	req->cmd[0] = START_STOP;
256	req->cmd[4] = 1;	/* Start spin cycle */
257	req->timeout = HP_SW_TIMEOUT;
258	req->sense = h->sense;
259	memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
260	req->sense_len = 0;
261	req->end_io_data = h;
262
263	blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
264	return SCSI_DH_OK;
265}
266
267static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
268{
269	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
270	int ret = BLKPREP_OK;
271
272	if (h->path_state != HP_SW_PATH_ACTIVE) {
273		ret = BLKPREP_KILL;
274		req->cmd_flags |= REQ_QUIET;
275	}
276	return ret;
277
278}
279
280/*
281 * hp_sw_activate - Activate a path
282 * @sdev: sdev on the path to be activated
283 *
284 * The HP Active/Passive firmware is pretty simple;
285 * the passive path reports NOT READY with sense codes
286 * 0x04/0x02; a START STOP UNIT command will then
287 * activate the passive path (and deactivate the
288 * previously active one).
289 */
290static int hp_sw_activate(struct scsi_device *sdev,
291				activate_complete fn, void *data)
292{
293	int ret = SCSI_DH_OK;
294	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
295
296	ret = hp_sw_tur(sdev, h);
297
298	if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
299		h->retry_cnt = h->retries;
300		h->callback_fn = fn;
301		h->callback_data = data;
302		ret = hp_sw_start_stop(h);
303		if (ret == SCSI_DH_OK)
304			return 0;
305		h->callback_fn = h->callback_data = NULL;
306	}
307
308	if (fn)
309		fn(data, ret);
310	return 0;
311}
312
313static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
314	{"COMPAQ", "MSA1000 VOLUME"},
315	{"COMPAQ", "HSV110"},
316	{"HP", "HSV100"},
317	{"DEC", "HSG80"},
318	{NULL, NULL},
319};
320
321static int hp_sw_bus_attach(struct scsi_device *sdev);
322static void hp_sw_bus_detach(struct scsi_device *sdev);
323
324static struct scsi_device_handler hp_sw_dh = {
325	.name		= HP_SW_NAME,
326	.module		= THIS_MODULE,
327	.devlist	= hp_sw_dh_data_list,
328	.attach		= hp_sw_bus_attach,
329	.detach		= hp_sw_bus_detach,
330	.activate	= hp_sw_activate,
331	.prep_fn	= hp_sw_prep_fn,
332};
333
334static int hp_sw_bus_attach(struct scsi_device *sdev)
335{
336	struct scsi_dh_data *scsi_dh_data;
337	struct hp_sw_dh_data *h;
338	unsigned long flags;
339	int ret;
340
341	scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
342			       + sizeof(struct hp_sw_dh_data) , GFP_KERNEL);
343	if (!scsi_dh_data) {
344		sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
345			    HP_SW_NAME);
346		return 0;
347	}
348
349	scsi_dh_data->scsi_dh = &hp_sw_dh;
350	h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
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	if (!try_module_get(THIS_MODULE))
360		goto failed;
361
362	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
363	sdev->scsi_dh_data = scsi_dh_data;
364	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
365
366	sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
367		    HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
368		    "active":"passive");
369
370	return 0;
371
372failed:
373	kfree(scsi_dh_data);
374	sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
375		    HP_SW_NAME);
376	return -EINVAL;
377}
378
379static void hp_sw_bus_detach( struct scsi_device *sdev )
380{
381	struct scsi_dh_data *scsi_dh_data;
382	unsigned long flags;
383
384	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
385	scsi_dh_data = sdev->scsi_dh_data;
386	sdev->scsi_dh_data = NULL;
387	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
388	module_put(THIS_MODULE);
389
390	sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", HP_SW_NAME);
391
392	kfree(scsi_dh_data);
393}
394
395static int __init hp_sw_init(void)
396{
397	return scsi_register_device_handler(&hp_sw_dh);
398}
399
400static void __exit hp_sw_exit(void)
401{
402	scsi_unregister_device_handler(&hp_sw_dh);
403}
404
405module_init(hp_sw_init);
406module_exit(hp_sw_exit);
407
408MODULE_DESCRIPTION("HP Active/Passive driver");
409MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
410MODULE_LICENSE("GPL");