[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 {
	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 *);

/*
 * 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 = sdev->handler_data;
	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 = sdev->handler_data;

	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 int 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 -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");

	sdev->handler_data = h;
	return 0;
failed:
	kfree(h);
	return -EINVAL;
}

static void hp_sw_bus_detach( struct scsi_device *sdev )
{
	kfree(sdev->handler_data);
	sdev->handler_data = NULL;
}

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,
};

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