[deliverable/linux.git] / drivers / scsi / device_handler / scsi_dh_hp_sw.c

/*
 * Basic HP/COMPAQ MSA 1000 support. This is only needed if your HW cannot be
 * upgraded.
 *
 * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
 * Copyright (C) 2006 Mike Christie
 * Copyright (C) 2008 Hannes Reinecke <hare@suse.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/slab.h>
#include <linux/module.h>
#include <scsi/scsi.h>
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_eh.h>
#include <scsi/scsi_dh.h>

#define HP_SW_NAME			"hp_sw"

#define HP_SW_TIMEOUT			(60 * HZ)
#define HP_SW_RETRIES			3

#define HP_SW_PATH_UNINITIALIZED	-1
#define HP_SW_PATH_ACTIVE		0
#define HP_SW_PATH_PASSIVE		1

struct hp_sw_dh_data {
	struct scsi_dh_data dh_data;
	unsigned char sense[SCSI_SENSE_BUFFERSIZE];
	int path_state;
	int retries;
	int retry_cnt;
	struct scsi_device *sdev;
	activate_complete	callback_fn;
	void			*callback_data;
};

static int hp_sw_start_stop(struct hp_sw_dh_data *);

static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
{
	return container_of(sdev->scsi_dh_data, struct hp_sw_dh_data, dh_data);
}

/*
 * tur_done - Handle TEST UNIT READY return status
 * @sdev: sdev the command has been sent to
 * @errors: blk error code
 *
 * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
 */
static int tur_done(struct scsi_device *sdev, unsigned char *sense)
{
	struct scsi_sense_hdr sshdr;
	int ret;

	ret = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
	if (!ret) {
		sdev_printk(KERN_WARNING, sdev,
			    "%s: sending tur failed, no sense available\n",
			    HP_SW_NAME);
		ret = SCSI_DH_IO;
		goto done;
	}
	switch (sshdr.sense_key) {
	case UNIT_ATTENTION:
		ret = SCSI_DH_IMM_RETRY;
		break;
	case NOT_READY:
		if ((sshdr.asc == 0x04) && (sshdr.ascq == 2)) {
			/*
			 * LUN not ready - Initialization command required
			 *
			 * This is the passive path
			 */
			ret = SCSI_DH_DEV_OFFLINED;
			break;
		}
		/* Fallthrough */
	default:
		sdev_printk(KERN_WARNING, sdev,
			   "%s: sending tur failed, sense %x/%x/%x\n",
			   HP_SW_NAME, sshdr.sense_key, sshdr.asc,
			   sshdr.ascq);
		break;
	}

done:
	return ret;
}

/*
 * hp_sw_tur - Send TEST UNIT READY
 * @sdev: sdev command should be sent to
 *
 * Use the TEST UNIT READY command to determine
 * the path state.
 */
static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
{
	struct request *req;
	int ret;

retry:
	req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
	if (IS_ERR(req))
		return SCSI_DH_RES_TEMP_UNAVAIL;

	blk_rq_set_block_pc(req);
	req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
			  REQ_FAILFAST_DRIVER;
	req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY);
	req->cmd[0] = TEST_UNIT_READY;
	req->timeout = HP_SW_TIMEOUT;
	req->sense = h->sense;
	memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
	req->sense_len = 0;

	ret = blk_execute_rq(req->q, NULL, req, 1);
	if (ret == -EIO) {
		if (req->sense_len > 0) {
			ret = tur_done(sdev, h->sense);
		} else {
			sdev_printk(KERN_WARNING, sdev,
				    "%s: sending tur failed with %x\n",
				    HP_SW_NAME, req->errors);
			ret = SCSI_DH_IO;
		}
	} else {
		h->path_state = HP_SW_PATH_ACTIVE;
		ret = SCSI_DH_OK;
	}
	if (ret == SCSI_DH_IMM_RETRY) {
		blk_put_request(req);
		goto retry;
	}
	if (ret == SCSI_DH_DEV_OFFLINED) {
		h->path_state = HP_SW_PATH_PASSIVE;
		ret = SCSI_DH_OK;
	}

	blk_put_request(req);

	return ret;
}

/*
 * start_done - Handle START STOP UNIT return status
 * @sdev: sdev the command has been sent to
 * @errors: blk error code
 */
static int start_done(struct scsi_device *sdev, unsigned char *sense)
{
	struct scsi_sense_hdr sshdr;
	int rc;

	rc = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
	if (!rc) {
		sdev_printk(KERN_WARNING, sdev,
			    "%s: sending start_stop_unit failed, "
			    "no sense available\n",
			    HP_SW_NAME);
		return SCSI_DH_IO;
	}
	switch (sshdr.sense_key) {
	case NOT_READY:
		if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
			/*
			 * LUN not ready - manual intervention required
			 *
			 * Switch-over in progress, retry.
			 */
			rc = SCSI_DH_RETRY;
			break;
		}
		/* fall through */
	default:
		sdev_printk(KERN_WARNING, sdev,
			   "%s: sending start_stop_unit failed, sense %x/%x/%x\n",
			   HP_SW_NAME, sshdr.sense_key, sshdr.asc,
			   sshdr.ascq);
		rc = SCSI_DH_IO;
	}

	return rc;
}

static void start_stop_endio(struct request *req, int error)
{
	struct hp_sw_dh_data *h = req->end_io_data;
	unsigned err = SCSI_DH_OK;

	if (error || host_byte(req->errors) != DID_OK ||
			msg_byte(req->errors) != COMMAND_COMPLETE) {
		sdev_printk(KERN_WARNING, h->sdev,
			    "%s: sending start_stop_unit failed with %x\n",
			    HP_SW_NAME, req->errors);
		err = SCSI_DH_IO;
		goto done;
	}

	if (req->sense_len > 0) {
		err = start_done(h->sdev, h->sense);
		if (err == SCSI_DH_RETRY) {
			err = SCSI_DH_IO;
			if (--h->retry_cnt) {
				blk_put_request(req);
				err = hp_sw_start_stop(h);
				if (err == SCSI_DH_OK)
					return;
			}
		}
	}
done:
	req->end_io_data = NULL;
	__blk_put_request(req->q, req);
	if (h->callback_fn) {
		h->callback_fn(h->callback_data, err);
		h->callback_fn = h->callback_data = NULL;
	}
	return;

}

/*
 * hp_sw_start_stop - Send START STOP UNIT command
 * @sdev: sdev command should be sent to
 *
 * Sending START STOP UNIT activates the SP.
 */
static int hp_sw_start_stop(struct hp_sw_dh_data *h)
{
	struct request *req;

	req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
	if (IS_ERR(req))
		return SCSI_DH_RES_TEMP_UNAVAIL;

	blk_rq_set_block_pc(req);
	req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
			  REQ_FAILFAST_DRIVER;
	req->cmd_len = COMMAND_SIZE(START_STOP);
	req->cmd[0] = START_STOP;
	req->cmd[4] = 1;	/* Start spin cycle */
	req->timeout = HP_SW_TIMEOUT;
	req->sense = h->sense;
	memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
	req->sense_len = 0;
	req->end_io_data = h;

	blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
	return SCSI_DH_OK;
}

static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
{
	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
	int ret = BLKPREP_OK;

	if (h->path_state != HP_SW_PATH_ACTIVE) {
		ret = BLKPREP_KILL;
		req->cmd_flags |= REQ_QUIET;
	}
	return ret;

}

/*
 * hp_sw_activate - Activate a path
 * @sdev: sdev on the path to be activated
 *
 * The HP Active/Passive firmware is pretty simple;
 * the passive path reports NOT READY with sense codes
 * 0x04/0x02; a START STOP UNIT command will then
 * activate the passive path (and deactivate the
 * previously active one).
 */
static int hp_sw_activate(struct scsi_device *sdev,
				activate_complete fn, void *data)
{
	int ret = SCSI_DH_OK;
	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);

	ret = hp_sw_tur(sdev, h);

	if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
		h->retry_cnt = h->retries;
		h->callback_fn = fn;
		h->callback_data = data;
		ret = hp_sw_start_stop(h);
		if (ret == SCSI_DH_OK)
			return 0;
		h->callback_fn = h->callback_data = NULL;
	}

	if (fn)
		fn(data, ret);
	return 0;
}

static const struct {
	char *vendor;
	char *model;
} hp_sw_dh_data_list[] = {
	{"COMPAQ", "MSA1000 VOLUME"},
	{"COMPAQ", "HSV110"},
	{"HP", "HSV100"},
	{"DEC", "HSG80"},
	{NULL, NULL},
};

static bool hp_sw_match(struct scsi_device *sdev)
{
	int i;

	if (scsi_device_tpgs(sdev))
		return false;

	for (i = 0; hp_sw_dh_data_list[i].vendor; i++) {
		if (!strncmp(sdev->vendor, hp_sw_dh_data_list[i].vendor,
			strlen(hp_sw_dh_data_list[i].vendor)) &&
		    !strncmp(sdev->model, hp_sw_dh_data_list[i].model,
			strlen(hp_sw_dh_data_list[i].model))) {
			return true;
		}
	}
	return false;
}

static struct scsi_dh_data *hp_sw_bus_attach(struct scsi_device *sdev)
{
	struct hp_sw_dh_data *h;
	int ret;

	h = kzalloc(sizeof(*h), GFP_KERNEL);
	if (!h)
		return ERR_PTR(-ENOMEM);
	h->path_state = HP_SW_PATH_UNINITIALIZED;
	h->retries = HP_SW_RETRIES;
	h->sdev = sdev;

	ret = hp_sw_tur(sdev, h);
	if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
		goto failed;

	sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
		    HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
		    "active":"passive");
	return &h->dh_data;
failed:
	kfree(h);
	return ERR_PTR(-EINVAL);
}

static void hp_sw_bus_detach( struct scsi_device *sdev )
{
	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);

	kfree(h);
}

static struct scsi_device_handler hp_sw_dh = {
	.name		= HP_SW_NAME,
	.module		= THIS_MODULE,
	.attach		= hp_sw_bus_attach,
	.detach		= hp_sw_bus_detach,
	.activate	= hp_sw_activate,
	.prep_fn	= hp_sw_prep_fn,
	.match		= hp_sw_match,
};

static int __init hp_sw_init(void)
{
	return scsi_register_device_handler(&hp_sw_dh);
}

static void __exit hp_sw_exit(void)
{
	scsi_unregister_device_handler(&hp_sw_dh);
}

module_init(hp_sw_init);
module_exit(hp_sw_exit);

MODULE_DESCRIPTION("HP Active/Passive driver");
MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
MODULE_LICENSE("GPL");
Commit	Line	Data
f6dd337e MC	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
2aef6d5c	7	* Copyright (C) 2008 Hannes Reinecke <hare@suse.de>
f6dd337e MC	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
5a0e3ad6	24	#include <linux/slab.h>
acf3368f	25	#include <linux/module.h>
f6dd337e MC	26	#include <scsi/scsi.h>
	27	#include <scsi/scsi_dbg.h>
	28	#include <scsi/scsi_eh.h>
	29	#include <scsi/scsi_dh.h>
	30
2aef6d5c	31	#define HP_SW_NAME "hp_sw"
f6dd337e	32
2aef6d5c HR	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
f6dd337e MC	39
f6dd337e MC	40	struct hp_sw_dh_data {
cd37743f	41	struct scsi_dh_data dh_data;
f6dd337e	42	unsigned char sense[SCSI_SENSE_BUFFERSIZE];
2aef6d5c	43	int path_state;
f6dd337e	44	int retries;
4e2ef86c CS	45	int retry_cnt;
	46	struct scsi_device *sdev;
	47	activate_complete callback_fn;
	48	void *callback_data;
f6dd337e MC	49	};
f6dd337e MC	50
4e2ef86c CS	51	static int hp_sw_start_stop(struct hp_sw_dh_data *);
4e2ef86c CS	52
f6dd337e MC	53	static inline struct hp_sw_dh_data get_hp_sw_data(struct scsi_device sdev)
f6dd337e MC	54	{
cd37743f	55	return container_of(sdev->scsi_dh_data, struct hp_sw_dh_data, dh_data);
f6dd337e MC	56	}
f6dd337e MC	57
2aef6d5c HR	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)
f6dd337e	66	{
f6dd337e	67	struct scsi_sense_hdr sshdr;
2aef6d5c	68	int ret;
f6dd337e	69
2aef6d5c HR	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;
f6dd337e	76	goto done;
2aef6d5c	77	}
f6dd337e	78	switch (sshdr.sense_key) {
2aef6d5c HR	79	case UNIT_ATTENTION:
	80	ret = SCSI_DH_IMM_RETRY;
	81	break;
f6dd337e	82	case NOT_READY:
2aef6d5c HR	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;
f6dd337e MC	90	break;
f6dd337e MC	91	}
2aef6d5c	92	/* Fallthrough */
f6dd337e	93	default:
2aef6d5c HR	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;
f6dd337e MC	99	}
	100
	101	done:
2aef6d5c HR	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
febd7a5c	117	retry:
2aef6d5c	118	req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
a492f075	119	if (IS_ERR(req))
2aef6d5c HR	120	return SCSI_DH_RES_TEMP_UNAVAIL;
2aef6d5c HR	121
f27b087b	122	blk_rq_set_block_pc(req);
6000a368 MC	123	req->cmd_flags \|= REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
6000a368 MC	124	REQ_FAILFAST_DRIVER;
2aef6d5c	125	req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY);
2aef6d5c HR	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
2aef6d5c HR	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	}
febd7a5c AB	146	if (ret == SCSI_DH_IMM_RETRY) {
febd7a5c AB	147	blk_put_request(req);
2aef6d5c	148	goto retry;
febd7a5c	149	}
2aef6d5c HR	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);
f6dd337e MC	195	rc = SCSI_DH_IO;
f6dd337e MC	196	}
2aef6d5c	197
f6dd337e MC	198	return rc;
	199	}
	200
4e2ef86c CS	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:
7a1e9d82 MS	228	req->end_io_data = NULL;
7a1e9d82 MS	229	__blk_put_request(req->q, req);
4e2ef86c CS	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
2aef6d5c HR	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	*/
4e2ef86c	244	static int hp_sw_start_stop(struct hp_sw_dh_data *h)
f6dd337e	245	{
f6dd337e	246	struct request *req;
f6dd337e	247
4e2ef86c	248	req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
a492f075	249	if (IS_ERR(req))
2aef6d5c	250	return SCSI_DH_RES_TEMP_UNAVAIL;
f6dd337e	251
f27b087b	252	blk_rq_set_block_pc(req);
6000a368 MC	253	req->cmd_flags \|= REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
6000a368 MC	254	REQ_FAILFAST_DRIVER;
f6dd337e	255	req->cmd_len = COMMAND_SIZE(START_STOP);
f6dd337e MC	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;
4e2ef86c	262	req->end_io_data = h;
2aef6d5c	263
4e2ef86c CS	264	blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
4e2ef86c CS	265	return SCSI_DH_OK;
2aef6d5c HR	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	*/
3ae31f6a CS	291	static int hp_sw_activate(struct scsi_device *sdev,
3ae31f6a CS	292	activate_complete fn, void *data)
2aef6d5c HR	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) {
4e2ef86c CS	300	h->retry_cnt = h->retries;
	301	h->callback_fn = fn;
	302	h->callback_data = data;
	303	ret = hp_sw_start_stop(h);
2aef6d5c	304	if (ret == SCSI_DH_OK)
4e2ef86c CS	305	return 0;
4e2ef86c CS	306	h->callback_fn = h->callback_data = NULL;
2aef6d5c HR	307	}
2aef6d5c HR	308
3ae31f6a CS	309	if (fn)
	310	fn(data, ret);
	311	return 0;
f6dd337e MC	312	}
f6dd337e MC	313
a64d01dc CH	314	static const struct {
	315	char *vendor;
	316	char *model;
	317	} hp_sw_dh_data_list[] = {
2aef6d5c HR	318	{"COMPAQ", "MSA1000 VOLUME"},
	319	{"COMPAQ", "HSV110"},
	320	{"HP", "HSV100"},
f6dd337e MC	321	{"DEC", "HSG80"},
	322	{NULL, NULL},
	323	};
	324
a315969e MB	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
1d520328	343	static struct scsi_dh_data hp_sw_bus_attach(struct scsi_device sdev)
f6dd337e	344	{
2aef6d5c	345	struct hp_sw_dh_data *h;
2aef6d5c	346	int ret;
f6dd337e	347
cd37743f	348	h = kzalloc(sizeof(*h), GFP_KERNEL);
1d520328 CH	349	if (!h)
1d520328 CH	350	return ERR_PTR(-ENOMEM);
2aef6d5c HR	351	h->path_state = HP_SW_PATH_UNINITIALIZED;
2aef6d5c HR	352	h->retries = HP_SW_RETRIES;
4e2ef86c	353	h->sdev = sdev;
2aef6d5c HR	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
2aef6d5c HR	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");
1d520328	362	return &h->dh_data;
2aef6d5c	363	failed:
cd37743f	364	kfree(h);
1d520328	365	return ERR_PTR(-EINVAL);
765cbc6d	366	}
f6dd337e	367
765cbc6d HR	368	static void hp_sw_bus_detach( struct scsi_device *sdev )
765cbc6d HR	369	{
cd37743f	370	struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
f6dd337e	371
cd37743f	372	kfree(h);
f6dd337e MC	373	}
f6dd337e MC	374
1d520328 CH	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
f6dd337e MC	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
2aef6d5c	398	MODULE_DESCRIPTION("HP Active/Passive driver");
f6dd337e MC	399	MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
f6dd337e MC	400	MODULE_LICENSE("GPL");