[mirror_ubuntu-artful-kernel.git] / drivers / scsi / device_handler / scsi_dh_rdac.c

/*
 * Engenio/LSI RDAC SCSI Device Handler
 *
 * Copyright (C) 2005 Mike Christie. All rights reserved.
 * Copyright (C) Chandra Seetharaman, IBM Corp. 2007
 *
 * 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 of the License, 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; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */
#include <scsi/scsi.h>
#include <scsi/scsi_eh.h>
#include <scsi/scsi_dh.h>

#define RDAC_NAME "rdac"
#define RDAC_RETRY_COUNT 5

/*
 * LSI mode page stuff
 *
 * These struct definitions and the forming of the
 * mode page were taken from the LSI RDAC 2.4 GPL'd
 * driver, and then converted to Linux conventions.
 */
#define RDAC_QUIESCENCE_TIME 20;
/*
 * Page Codes
 */
#define RDAC_PAGE_CODE_REDUNDANT_CONTROLLER 0x2c

/*
 * Controller modes definitions
 */
#define RDAC_MODE_TRANSFER_SPECIFIED_LUNS	0x02

/*
 * RDAC Options field
 */
#define RDAC_FORCED_QUIESENCE 0x02

#define RDAC_TIMEOUT	(60 * HZ)
#define RDAC_RETRIES	3

struct rdac_mode_6_hdr {
	u8	data_len;
	u8	medium_type;
	u8	device_params;
	u8	block_desc_len;
};

struct rdac_mode_10_hdr {
	u16	data_len;
	u8	medium_type;
	u8	device_params;
	u16	reserved;
	u16	block_desc_len;
};

struct rdac_mode_common {
	u8	controller_serial[16];
	u8	alt_controller_serial[16];
	u8	rdac_mode[2];
	u8	alt_rdac_mode[2];
	u8	quiescence_timeout;
	u8	rdac_options;
};

struct rdac_pg_legacy {
	struct rdac_mode_6_hdr hdr;
	u8	page_code;
	u8	page_len;
	struct rdac_mode_common common;
#define MODE6_MAX_LUN	32
	u8	lun_table[MODE6_MAX_LUN];
	u8	reserved2[32];
	u8	reserved3;
	u8	reserved4;
};

struct rdac_pg_expanded {
	struct rdac_mode_10_hdr hdr;
	u8	page_code;
	u8	subpage_code;
	u8	page_len[2];
	struct rdac_mode_common common;
	u8	lun_table[256];
	u8	reserved3;
	u8	reserved4;
};

struct c9_inquiry {
	u8	peripheral_info;
	u8	page_code;	/* 0xC9 */
	u8	reserved1;
	u8	page_len;
	u8	page_id[4];	/* "vace" */
	u8	avte_cvp;
	u8	path_prio;
	u8	reserved2[38];
};

#define SUBSYS_ID_LEN	16
#define SLOT_ID_LEN	2

struct c4_inquiry {
	u8	peripheral_info;
	u8	page_code;	/* 0xC4 */
	u8	reserved1;
	u8	page_len;
	u8	page_id[4];	/* "subs" */
	u8	subsys_id[SUBSYS_ID_LEN];
	u8	revision[4];
	u8	slot_id[SLOT_ID_LEN];
	u8	reserved[2];
};

struct rdac_controller {
	u8			subsys_id[SUBSYS_ID_LEN];
	u8			slot_id[SLOT_ID_LEN];
	int			use_ms10;
	struct kref		kref;
	struct list_head	node; /* list of all controllers */
	union			{
		struct rdac_pg_legacy legacy;
		struct rdac_pg_expanded expanded;
	} mode_select;
};
struct c8_inquiry {
	u8	peripheral_info;
	u8	page_code; /* 0xC8 */
	u8	reserved1;
	u8	page_len;
	u8	page_id[4]; /* "edid" */
	u8	reserved2[3];
	u8	vol_uniq_id_len;
	u8	vol_uniq_id[16];
	u8	vol_user_label_len;
	u8	vol_user_label[60];
	u8	array_uniq_id_len;
	u8	array_unique_id[16];
	u8	array_user_label_len;
	u8	array_user_label[60];
	u8	lun[8];
};

struct c2_inquiry {
	u8	peripheral_info;
	u8	page_code;	/* 0xC2 */
	u8	reserved1;
	u8	page_len;
	u8	page_id[4];	/* "swr4" */
	u8	sw_version[3];
	u8	sw_date[3];
	u8	features_enabled;
	u8	max_lun_supported;
	u8	partitions[239]; /* Total allocation length should be 0xFF */
};

struct rdac_dh_data {
	struct rdac_controller	*ctlr;
#define UNINITIALIZED_LUN	(1 << 8)
	unsigned		lun;
#define RDAC_STATE_ACTIVE	0
#define RDAC_STATE_PASSIVE	1
	unsigned char		state;

#define RDAC_LUN_UNOWNED	0
#define RDAC_LUN_OWNED		1
#define RDAC_LUN_AVT		2
	char			lun_state;
	unsigned char		sense[SCSI_SENSE_BUFFERSIZE];
	union			{
		struct c2_inquiry c2;
		struct c4_inquiry c4;
		struct c8_inquiry c8;
		struct c9_inquiry c9;
	} inq;
};

static const char *lun_state[] =
{
	"unowned",
	"owned",
	"owned (AVT mode)",
};

static LIST_HEAD(ctlr_list);
static DEFINE_SPINLOCK(list_lock);

static inline struct rdac_dh_data *get_rdac_data(struct scsi_device *sdev)
{
	struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
	BUG_ON(scsi_dh_data == NULL);
	return ((struct rdac_dh_data *) scsi_dh_data->buf);
}

static struct request *get_rdac_req(struct scsi_device *sdev,
			void *buffer, unsigned buflen, int rw)
{
	struct request *rq;
	struct request_queue *q = sdev->request_queue;

	rq = blk_get_request(q, rw, GFP_NOIO);

	if (!rq) {
		sdev_printk(KERN_INFO, sdev,
				"get_rdac_req: blk_get_request failed.\n");
		return NULL;
	}

	if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
		blk_put_request(rq);
		sdev_printk(KERN_INFO, sdev,
				"get_rdac_req: blk_rq_map_kern failed.\n");
		return NULL;
	}

	rq->cmd_type = REQ_TYPE_BLOCK_PC;
	rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
			 REQ_FAILFAST_DRIVER;
	rq->retries = RDAC_RETRIES;
	rq->timeout = RDAC_TIMEOUT;

	return rq;
}

static struct request *rdac_failover_get(struct scsi_device *sdev,
					 struct rdac_dh_data *h)
{
	struct request *rq;
	struct rdac_mode_common *common;
	unsigned data_size;

	if (h->ctlr->use_ms10) {
		struct rdac_pg_expanded *rdac_pg;

		data_size = sizeof(struct rdac_pg_expanded);
		rdac_pg = &h->ctlr->mode_select.expanded;
		memset(rdac_pg, 0, data_size);
		common = &rdac_pg->common;
		rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER + 0x40;
		rdac_pg->subpage_code = 0x1;
		rdac_pg->page_len[0] = 0x01;
		rdac_pg->page_len[1] = 0x28;
		rdac_pg->lun_table[h->lun] = 0x81;
	} else {
		struct rdac_pg_legacy *rdac_pg;

		data_size = sizeof(struct rdac_pg_legacy);
		rdac_pg = &h->ctlr->mode_select.legacy;
		memset(rdac_pg, 0, data_size);
		common = &rdac_pg->common;
		rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER;
		rdac_pg->page_len = 0x68;
		rdac_pg->lun_table[h->lun] = 0x81;
	}
	common->rdac_mode[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS;
	common->quiescence_timeout = RDAC_QUIESCENCE_TIME;
	common->rdac_options = RDAC_FORCED_QUIESENCE;

	/* get request for block layer packet command */
	rq = get_rdac_req(sdev, &h->ctlr->mode_select, data_size, WRITE);
	if (!rq)
		return NULL;

	/* Prepare the command. */
	if (h->ctlr->use_ms10) {
		rq->cmd[0] = MODE_SELECT_10;
		rq->cmd[7] = data_size >> 8;
		rq->cmd[8] = data_size & 0xff;
	} else {
		rq->cmd[0] = MODE_SELECT;
		rq->cmd[4] = data_size;
	}
	rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);

	rq->sense = h->sense;
	memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
	rq->sense_len = 0;

	return rq;
}

static void release_controller(struct kref *kref)
{
	struct rdac_controller *ctlr;
	ctlr = container_of(kref, struct rdac_controller, kref);

	spin_lock(&list_lock);
	list_del(&ctlr->node);
	spin_unlock(&list_lock);
	kfree(ctlr);
}

static struct rdac_controller *get_controller(u8 *subsys_id, u8 *slot_id)
{
	struct rdac_controller *ctlr, *tmp;

	spin_lock(&list_lock);

	list_for_each_entry(tmp, &ctlr_list, node) {
		if ((memcmp(tmp->subsys_id, subsys_id, SUBSYS_ID_LEN) == 0) &&
			  (memcmp(tmp->slot_id, slot_id, SLOT_ID_LEN) == 0)) {
			kref_get(&tmp->kref);
			spin_unlock(&list_lock);
			return tmp;
		}
	}
	ctlr = kmalloc(sizeof(*ctlr), GFP_ATOMIC);
	if (!ctlr)
		goto done;

	/* initialize fields of controller */
	memcpy(ctlr->subsys_id, subsys_id, SUBSYS_ID_LEN);
	memcpy(ctlr->slot_id, slot_id, SLOT_ID_LEN);
	kref_init(&ctlr->kref);
	ctlr->use_ms10 = -1;
	list_add(&ctlr->node, &ctlr_list);
done:
	spin_unlock(&list_lock);
	return ctlr;
}

static int submit_inquiry(struct scsi_device *sdev, int page_code,
			  unsigned int len, struct rdac_dh_data *h)
{
	struct request *rq;
	struct request_queue *q = sdev->request_queue;
	int err = SCSI_DH_RES_TEMP_UNAVAIL;

	rq = get_rdac_req(sdev, &h->inq, len, READ);
	if (!rq)
		goto done;

	/* Prepare the command. */
	rq->cmd[0] = INQUIRY;
	rq->cmd[1] = 1;
	rq->cmd[2] = page_code;
	rq->cmd[4] = len;
	rq->cmd_len = COMMAND_SIZE(INQUIRY);

	rq->sense = h->sense;
	memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
	rq->sense_len = 0;

	err = blk_execute_rq(q, NULL, rq, 1);
	if (err == -EIO)
		err = SCSI_DH_IO;

	blk_put_request(rq);
done:
	return err;
}

static int get_lun(struct scsi_device *sdev, struct rdac_dh_data *h)
{
	int err;
	struct c8_inquiry *inqp;

	err = submit_inquiry(sdev, 0xC8, sizeof(struct c8_inquiry), h);
	if (err == SCSI_DH_OK) {
		inqp = &h->inq.c8;
		if (inqp->page_code != 0xc8)
			return SCSI_DH_NOSYS;
		if (inqp->page_id[0] != 'e' || inqp->page_id[1] != 'd' ||
		    inqp->page_id[2] != 'i' || inqp->page_id[3] != 'd')
			return SCSI_DH_NOSYS;
		h->lun = inqp->lun[7]; /* Uses only the last byte */
	}
	return err;
}

static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
{
	int err;
	struct c9_inquiry *inqp;

	h->lun_state = RDAC_LUN_UNOWNED;
	h->state = RDAC_STATE_ACTIVE;
	err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
	if (err == SCSI_DH_OK) {
		inqp = &h->inq.c9;
		if ((inqp->avte_cvp >> 7) == 0x1) {
			/* LUN in AVT mode */
			sdev_printk(KERN_NOTICE, sdev,
				    "%s: AVT mode detected\n",
				    RDAC_NAME);
			h->lun_state = RDAC_LUN_AVT;
		} else if ((inqp->avte_cvp & 0x1) != 0) {
			/* LUN was owned by the controller */
			h->lun_state = RDAC_LUN_OWNED;
		}
	}

	if (h->lun_state == RDAC_LUN_UNOWNED)
		h->state = RDAC_STATE_PASSIVE;

	return err;
}

static int initialize_controller(struct scsi_device *sdev,
				 struct rdac_dh_data *h)
{
	int err;
	struct c4_inquiry *inqp;

	err = submit_inquiry(sdev, 0xC4, sizeof(struct c4_inquiry), h);
	if (err == SCSI_DH_OK) {
		inqp = &h->inq.c4;
		h->ctlr = get_controller(inqp->subsys_id, inqp->slot_id);
		if (!h->ctlr)
			err = SCSI_DH_RES_TEMP_UNAVAIL;
	}
	return err;
}

static int set_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
{
	int err;
	struct c2_inquiry *inqp;

	err = submit_inquiry(sdev, 0xC2, sizeof(struct c2_inquiry), h);
	if (err == SCSI_DH_OK) {
		inqp = &h->inq.c2;
		/*
		 * If more than MODE6_MAX_LUN luns are supported, use
		 * mode select 10
		 */
		if (inqp->max_lun_supported >= MODE6_MAX_LUN)
			h->ctlr->use_ms10 = 1;
		else
			h->ctlr->use_ms10 = 0;
	}
	return err;
}

static int mode_select_handle_sense(struct scsi_device *sdev,
				    unsigned char *sensebuf)
{
	struct scsi_sense_hdr sense_hdr;
	int sense, err = SCSI_DH_IO, ret;

	ret = scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE, &sense_hdr);
	if (!ret)
		goto done;

	err = SCSI_DH_OK;
	sense = (sense_hdr.sense_key << 16) | (sense_hdr.asc << 8) |
			sense_hdr.ascq;
	/* If it is retryable failure, submit the c9 inquiry again */
	if (sense == 0x59136 || sense == 0x68b02 || sense == 0xb8b02 ||
			    sense == 0x62900) {
		/* 0x59136    - Command lock contention
		 * 0x[6b]8b02 - Quiesense in progress or achieved
		 * 0x62900    - Power On, Reset, or Bus Device Reset
		 */
		err = SCSI_DH_RETRY;
	}

	if (sense)
		sdev_printk(KERN_INFO, sdev,
			"MODE_SELECT failed with sense 0x%x.\n", sense);
done:
	return err;
}

static int send_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
{
	struct request *rq;
	struct request_queue *q = sdev->request_queue;
	int err, retry_cnt = RDAC_RETRY_COUNT;

retry:
	err = SCSI_DH_RES_TEMP_UNAVAIL;
	rq = rdac_failover_get(sdev, h);
	if (!rq)
		goto done;

	sdev_printk(KERN_INFO, sdev, "%s MODE_SELECT command.\n",
		(retry_cnt == RDAC_RETRY_COUNT) ? "queueing" : "retrying");

	err = blk_execute_rq(q, NULL, rq, 1);
	blk_put_request(rq);
	if (err != SCSI_DH_OK) {
		err = mode_select_handle_sense(sdev, h->sense);
		if (err == SCSI_DH_RETRY && retry_cnt--)
			goto retry;
	}
	if (err == SCSI_DH_OK)
		h->state = RDAC_STATE_ACTIVE;

done:
	return err;
}

static int rdac_activate(struct scsi_device *sdev)
{
	struct rdac_dh_data *h = get_rdac_data(sdev);
	int err = SCSI_DH_OK;

	err = check_ownership(sdev, h);
	if (err != SCSI_DH_OK)
		goto done;

	if (!h->ctlr) {
		err = initialize_controller(sdev, h);
		if (err != SCSI_DH_OK)
			goto done;
	}

	if (h->ctlr->use_ms10 == -1) {
		err = set_mode_select(sdev, h);
		if (err != SCSI_DH_OK)
			goto done;
	}
	if (h->lun_state == RDAC_LUN_UNOWNED)
		err = send_mode_select(sdev, h);
done:
	return err;
}

static int rdac_prep_fn(struct scsi_device *sdev, struct request *req)
{
	struct rdac_dh_data *h = get_rdac_data(sdev);
	int ret = BLKPREP_OK;

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

}

static int rdac_check_sense(struct scsi_device *sdev,
				struct scsi_sense_hdr *sense_hdr)
{
	struct rdac_dh_data *h = get_rdac_data(sdev);
	switch (sense_hdr->sense_key) {
	case NOT_READY:
		if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x81)
			/* LUN Not Ready - Storage firmware incompatible
			 * Manual code synchonisation required.
			 *
			 * Nothing we can do here. Try to bypass the path.
			 */
			return SUCCESS;
		if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0xA1)
			/* LUN Not Ready - Quiescense in progress
			 *
			 * Just retry and wait.
			 */
			return ADD_TO_MLQUEUE;
		break;
	case ILLEGAL_REQUEST:
		if (sense_hdr->asc == 0x94 && sense_hdr->ascq == 0x01) {
			/* Invalid Request - Current Logical Unit Ownership.
			 * Controller is not the current owner of the LUN,
			 * Fail the path, so that the other path be used.
			 */
			h->state = RDAC_STATE_PASSIVE;
			return SUCCESS;
		}
		break;
	case UNIT_ATTENTION:
		if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
			/*
			 * Power On, Reset, or Bus Device Reset, just retry.
			 */
			return ADD_TO_MLQUEUE;
		if (sense_hdr->asc == 0x8b && sense_hdr->ascq == 0x02)
			/*
			 * Quiescence in progress , just retry.
			 */
			return ADD_TO_MLQUEUE;
		break;
	}
	/* success just means we do not care what scsi-ml does */
	return SCSI_RETURN_NOT_HANDLED;
}

static const struct scsi_dh_devlist rdac_dev_list[] = {
	{"IBM", "1722"},
	{"IBM", "1724"},
	{"IBM", "1726"},
	{"IBM", "1742"},
	{"IBM", "1814"},
	{"IBM", "1815"},
	{"IBM", "1818"},
	{"IBM", "3526"},
	{"SGI", "TP9400"},
	{"SGI", "TP9500"},
	{"SGI", "IS"},
	{"STK", "OPENstorage D280"},
	{"SUN", "CSM200_R"},
	{"SUN", "LCSM100_F"},
	{"DELL", "MD3000"},
	{"DELL", "MD3000i"},
	{"LSI", "INF-01-00"},
	{"ENGENIO", "INF-01-00"},
	{NULL, NULL},
};

static int rdac_bus_attach(struct scsi_device *sdev);
static void rdac_bus_detach(struct scsi_device *sdev);

static struct scsi_device_handler rdac_dh = {
	.name = RDAC_NAME,
	.module = THIS_MODULE,
	.devlist = rdac_dev_list,
	.prep_fn = rdac_prep_fn,
	.check_sense = rdac_check_sense,
	.attach = rdac_bus_attach,
	.detach = rdac_bus_detach,
	.activate = rdac_activate,
};

static int rdac_bus_attach(struct scsi_device *sdev)
{
	struct scsi_dh_data *scsi_dh_data;
	struct rdac_dh_data *h;
	unsigned long flags;
	int err;

	scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
			       + sizeof(*h) , GFP_KERNEL);
	if (!scsi_dh_data) {
		sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
			    RDAC_NAME);
		return 0;
	}

	scsi_dh_data->scsi_dh = &rdac_dh;
	h = (struct rdac_dh_data *) scsi_dh_data->buf;
	h->lun = UNINITIALIZED_LUN;
	h->state = RDAC_STATE_ACTIVE;

	err = get_lun(sdev, h);
	if (err != SCSI_DH_OK)
		goto failed;

	err = check_ownership(sdev, h);
	if (err != SCSI_DH_OK)
		goto failed;

	if (!try_module_get(THIS_MODULE))
		goto failed;

	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
	sdev->scsi_dh_data = scsi_dh_data;
	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);

	sdev_printk(KERN_NOTICE, sdev,
		    "%s: LUN %d (%s)\n",
		    RDAC_NAME, h->lun, lun_state[(int)h->lun_state]);

	return 0;

failed:
	kfree(scsi_dh_data);
	sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
		    RDAC_NAME);
	return -EINVAL;
}

static void rdac_bus_detach( struct scsi_device *sdev )
{
	struct scsi_dh_data *scsi_dh_data;
	struct rdac_dh_data *h;
	unsigned long flags;

	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
	scsi_dh_data = sdev->scsi_dh_data;
	sdev->scsi_dh_data = NULL;
	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);

	h = (struct rdac_dh_data *) scsi_dh_data->buf;
	if (h->ctlr)
		kref_put(&h->ctlr->kref, release_controller);
	kfree(scsi_dh_data);
	module_put(THIS_MODULE);
	sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", RDAC_NAME);
}


static int __init rdac_init(void)
{
	int r;

	r = scsi_register_device_handler(&rdac_dh);
	if (r != 0)
		printk(KERN_ERR "Failed to register scsi device handler.");
	return r;
}

static void __exit rdac_exit(void)
{
	scsi_unregister_device_handler(&rdac_dh);
}

module_init(rdac_init);
module_exit(rdac_exit);

MODULE_DESCRIPTION("Multipath LSI/Engenio RDAC driver");
MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
MODULE_LICENSE("GPL");
Commit	Line	Data
fbd7ab3e CS	1	/*
	2	* Engenio/LSI RDAC SCSI Device Handler
	3	*
	4	* Copyright (C) 2005 Mike Christie. All rights reserved.
	5	* Copyright (C) Chandra Seetharaman, IBM Corp. 2007
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	20	*
	21	*/
	22	#include <scsi/scsi.h>
	23	#include <scsi/scsi_eh.h>
	24	#include <scsi/scsi_dh.h>
	25
	26	#define RDAC_NAME "rdac"
c85f8cb9	27	#define RDAC_RETRY_COUNT 5
fbd7ab3e CS	28
	29	/*
	30	* LSI mode page stuff
	31	*
	32	* These struct definitions and the forming of the
	33	* mode page were taken from the LSI RDAC 2.4 GPL'd
	34	* driver, and then converted to Linux conventions.
	35	*/
	36	#define RDAC_QUIESCENCE_TIME 20;
	37	/*
	38	* Page Codes
	39	*/
	40	#define RDAC_PAGE_CODE_REDUNDANT_CONTROLLER 0x2c
	41
	42	/*
	43	* Controller modes definitions
	44	*/
	45	#define RDAC_MODE_TRANSFER_SPECIFIED_LUNS 0x02
	46
	47	/*
	48	* RDAC Options field
	49	*/
	50	#define RDAC_FORCED_QUIESENCE 0x02
	51
	52	#define RDAC_TIMEOUT (60 * HZ)
	53	#define RDAC_RETRIES 3
	54
	55	struct rdac_mode_6_hdr {
	56	u8 data_len;
	57	u8 medium_type;
	58	u8 device_params;
	59	u8 block_desc_len;
	60	};
	61
	62	struct rdac_mode_10_hdr {
	63	u16 data_len;
	64	u8 medium_type;
	65	u8 device_params;
	66	u16 reserved;
	67	u16 block_desc_len;
	68	};
	69
	70	struct rdac_mode_common {
	71	u8 controller_serial[16];
	72	u8 alt_controller_serial[16];
	73	u8 rdac_mode[2];
	74	u8 alt_rdac_mode[2];
	75	u8 quiescence_timeout;
	76	u8 rdac_options;
	77	};
	78
	79	struct rdac_pg_legacy {
	80	struct rdac_mode_6_hdr hdr;
	81	u8 page_code;
	82	u8 page_len;
	83	struct rdac_mode_common common;
	84	#define MODE6_MAX_LUN 32
	85	u8 lun_table[MODE6_MAX_LUN];
	86	u8 reserved2[32];
	87	u8 reserved3;
	88	u8 reserved4;
	89	};
	90
	91	struct rdac_pg_expanded {
92	struct rdac_mode_10_hdr hdr;
93	u8 page_code;
94	u8 subpage_code;
95	u8 page_len[2];
96	struct rdac_mode_common common;
97	u8 lun_table[256];
98	u8 reserved3;
99	u8 reserved4;
100	};
101
102	struct c9_inquiry {
103	u8 peripheral_info;
104	u8 page_code; /* 0xC9 */
105	u8 reserved1;
106	u8 page_len;
107	u8 page_id[4]; /* "vace" */
108	u8 avte_cvp;
109	u8 path_prio;
110	u8 reserved2[38];
111	};
112
113	#define SUBSYS_ID_LEN 16
114	#define SLOT_ID_LEN 2
115
116	struct c4_inquiry {
117	u8 peripheral_info;
118	u8 page_code; /* 0xC4 */
119	u8 reserved1;
120	u8 page_len;
121	u8 page_id[4]; /* "subs" */
122	u8 subsys_id[SUBSYS_ID_LEN];
123	u8 revision[4];
124	u8 slot_id[SLOT_ID_LEN];
125	u8 reserved[2];
126	};
127
128	struct rdac_controller {
129	u8 subsys_id[SUBSYS_ID_LEN];
130	u8 slot_id[SLOT_ID_LEN];
131	int use_ms10;
132	struct kref kref;
133	struct list_head node; /* list of all controllers */
134	union {
135	struct rdac_pg_legacy legacy;
136	struct rdac_pg_expanded expanded;
137	} mode_select;
138	};
139	struct c8_inquiry {
140	u8 peripheral_info;
141	u8 page_code; /* 0xC8 */
142	u8 reserved1;
143	u8 page_len;
144	u8 page_id[4]; /* "edid" */
145	u8 reserved2[3];
146	u8 vol_uniq_id_len;
147	u8 vol_uniq_id[16];
148	u8 vol_user_label_len;
149	u8 vol_user_label[60];
150	u8 array_uniq_id_len;
151	u8 array_unique_id[16];
152	u8 array_user_label_len;
153	u8 array_user_label[60];
154	u8 lun[8];
155	};
156
157	struct c2_inquiry {
158	u8 peripheral_info;
159	u8 page_code; /* 0xC2 */
160	u8 reserved1;
161	u8 page_len;
162	u8 page_id[4]; /* "swr4" */
163	u8 sw_version[3];
164	u8 sw_date[3];
165	u8 features_enabled;
166	u8 max_lun_supported;
167	u8 partitions[239]; /* Total allocation length should be 0xFF */
168	};
169
170	struct rdac_dh_data {
171	struct rdac_controller *ctlr;
172	#define UNINITIALIZED_LUN (1 << 8)
173	unsigned lun;
174	#define RDAC_STATE_ACTIVE 0
175	#define RDAC_STATE_PASSIVE 1
176	unsigned char state;
ca9f0089 HR	177
	178	#define RDAC_LUN_UNOWNED 0
	179	#define RDAC_LUN_OWNED 1
	180	#define RDAC_LUN_AVT 2
	181	char lun_state;
fbd7ab3e CS	182	unsigned char sense[SCSI_SENSE_BUFFERSIZE];
	183	union {
	184	struct c2_inquiry c2;
	185	struct c4_inquiry c4;
	186	struct c8_inquiry c8;
	187	struct c9_inquiry c9;
	188	} inq;
	189	};
	190
ca9f0089 HR	191	static const char *lun_state[] =
	192	{
	193	"unowned",
	194	"owned",
	195	"owned (AVT mode)",
	196	};
	197
fbd7ab3e CS	198	static LIST_HEAD(ctlr_list);
	199	static DEFINE_SPINLOCK(list_lock);
	200
	201	static inline struct rdac_dh_data get_rdac_data(struct scsi_device sdev)
	202	{
	203	struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
	204	BUG_ON(scsi_dh_data == NULL);
	205	return ((struct rdac_dh_data *) scsi_dh_data->buf);
	206	}
	207
	208	static struct request get_rdac_req(struct scsi_device sdev,
	209	void *buffer, unsigned buflen, int rw)
	210	{
	211	struct request *rq;
	212	struct request_queue *q = sdev->request_queue;
fbd7ab3e	213
ca9f0089	214	rq = blk_get_request(q, rw, GFP_NOIO);
fbd7ab3e CS	215
	216	if (!rq) {
	217	sdev_printk(KERN_INFO, sdev,
	218	"get_rdac_req: blk_get_request failed.\n");
	219	return NULL;
	220	}
	221
ca9f0089	222	if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
fbd7ab3e CS	223	blk_put_request(rq);
	224	sdev_printk(KERN_INFO, sdev,
	225	"get_rdac_req: blk_rq_map_kern failed.\n");
	226	return NULL;
	227	}
	228
fbd7ab3e	229	rq->cmd_type = REQ_TYPE_BLOCK_PC;
6000a368 MC	230	rq->cmd_flags \|= REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
6000a368 MC	231	REQ_FAILFAST_DRIVER;
fbd7ab3e CS	232	rq->retries = RDAC_RETRIES;
	233	rq->timeout = RDAC_TIMEOUT;
	234
	235	return rq;
	236	}
	237
ca9f0089 HR	238	static struct request rdac_failover_get(struct scsi_device sdev,
ca9f0089 HR	239	struct rdac_dh_data *h)
fbd7ab3e CS	240	{
	241	struct request *rq;
	242	struct rdac_mode_common *common;
	243	unsigned data_size;
fbd7ab3e CS	244
	245	if (h->ctlr->use_ms10) {
	246	struct rdac_pg_expanded *rdac_pg;
	247
	248	data_size = sizeof(struct rdac_pg_expanded);
	249	rdac_pg = &h->ctlr->mode_select.expanded;
	250	memset(rdac_pg, 0, data_size);
	251	common = &rdac_pg->common;
	252	rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER + 0x40;
	253	rdac_pg->subpage_code = 0x1;
	254	rdac_pg->page_len[0] = 0x01;
	255	rdac_pg->page_len[1] = 0x28;
	256	rdac_pg->lun_table[h->lun] = 0x81;
	257	} else {
	258	struct rdac_pg_legacy *rdac_pg;
	259
	260	data_size = sizeof(struct rdac_pg_legacy);
	261	rdac_pg = &h->ctlr->mode_select.legacy;
	262	memset(rdac_pg, 0, data_size);
	263	common = &rdac_pg->common;
	264	rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER;
	265	rdac_pg->page_len = 0x68;
	266	rdac_pg->lun_table[h->lun] = 0x81;
	267	}
	268	common->rdac_mode[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS;
	269	common->quiescence_timeout = RDAC_QUIESCENCE_TIME;
	270	common->rdac_options = RDAC_FORCED_QUIESENCE;
	271
	272	/* get request for block layer packet command */
	273	rq = get_rdac_req(sdev, &h->ctlr->mode_select, data_size, WRITE);
	274	if (!rq)
	275	return NULL;
	276
	277	/* Prepare the command. */
	278	if (h->ctlr->use_ms10) {
	279	rq->cmd[0] = MODE_SELECT_10;
	280	rq->cmd[7] = data_size >> 8;
	281	rq->cmd[8] = data_size & 0xff;
	282	} else {
	283	rq->cmd[0] = MODE_SELECT;
	284	rq->cmd[4] = data_size;
	285	}
	286	rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
	287
ca9f0089 HR	288	rq->sense = h->sense;
	289	memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
	290	rq->sense_len = 0;
	291
fbd7ab3e CS	292	return rq;
	293	}
	294
	295	static void release_controller(struct kref *kref)
	296	{
	297	struct rdac_controller *ctlr;
	298	ctlr = container_of(kref, struct rdac_controller, kref);
	299
	300	spin_lock(&list_lock);
	301	list_del(&ctlr->node);
	302	spin_unlock(&list_lock);
	303	kfree(ctlr);
	304	}
	305
	306	static struct rdac_controller get_controller(u8 subsys_id, u8 *slot_id)
	307	{
	308	struct rdac_controller ctlr, tmp;
	309
	310	spin_lock(&list_lock);
	311
	312	list_for_each_entry(tmp, &ctlr_list, node) {
	313	if ((memcmp(tmp->subsys_id, subsys_id, SUBSYS_ID_LEN) == 0) &&
	314	(memcmp(tmp->slot_id, slot_id, SLOT_ID_LEN) == 0)) {
	315	kref_get(&tmp->kref);
	316	spin_unlock(&list_lock);
	317	return tmp;
	318	}
	319	}
	320	ctlr = kmalloc(sizeof(*ctlr), GFP_ATOMIC);
	321	if (!ctlr)
	322	goto done;
	323
	324	/* initialize fields of controller */
	325	memcpy(ctlr->subsys_id, subsys_id, SUBSYS_ID_LEN);
	326	memcpy(ctlr->slot_id, slot_id, SLOT_ID_LEN);
	327	kref_init(&ctlr->kref);
	328	ctlr->use_ms10 = -1;
	329	list_add(&ctlr->node, &ctlr_list);
	330	done:
	331	spin_unlock(&list_lock);
	332	return ctlr;
	333	}
	334
	335	static int submit_inquiry(struct scsi_device *sdev, int page_code,
ca9f0089	336	unsigned int len, struct rdac_dh_data *h)
fbd7ab3e CS	337	{
	338	struct request *rq;
	339	struct request_queue *q = sdev->request_queue;
fbd7ab3e CS	340	int err = SCSI_DH_RES_TEMP_UNAVAIL;
	341
	342	rq = get_rdac_req(sdev, &h->inq, len, READ);
	343	if (!rq)
	344	goto done;
	345
	346	/* Prepare the command. */
	347	rq->cmd[0] = INQUIRY;
	348	rq->cmd[1] = 1;
	349	rq->cmd[2] = page_code;
	350	rq->cmd[4] = len;
	351	rq->cmd_len = COMMAND_SIZE(INQUIRY);
ca9f0089 HR	352
	353	rq->sense = h->sense;
	354	memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
	355	rq->sense_len = 0;
	356
fbd7ab3e CS	357	err = blk_execute_rq(q, NULL, rq, 1);
	358	if (err == -EIO)
	359	err = SCSI_DH_IO;
ca9f0089 HR	360
ca9f0089 HR	361	blk_put_request(rq);
fbd7ab3e CS	362	done:
	363	return err;
	364	}
	365
ca9f0089	366	static int get_lun(struct scsi_device sdev, struct rdac_dh_data h)
fbd7ab3e CS	367	{
	368	int err;
	369	struct c8_inquiry *inqp;
fbd7ab3e	370
ca9f0089	371	err = submit_inquiry(sdev, 0xC8, sizeof(struct c8_inquiry), h);
fbd7ab3e CS	372	if (err == SCSI_DH_OK) {
fbd7ab3e CS	373	inqp = &h->inq.c8;
ca9f0089 HR	374	if (inqp->page_code != 0xc8)
	375	return SCSI_DH_NOSYS;
	376	if (inqp->page_id[0] != 'e' \|\| inqp->page_id[1] != 'd' \|\|
	377	inqp->page_id[2] != 'i' \|\| inqp->page_id[3] != 'd')
	378	return SCSI_DH_NOSYS;
8479fca1	379	h->lun = inqp->lun[7]; /* Uses only the last byte */
fbd7ab3e CS	380	}
	381	return err;
	382	}
	383
ca9f0089	384	static int check_ownership(struct scsi_device sdev, struct rdac_dh_data h)
fbd7ab3e CS	385	{
	386	int err;
	387	struct c9_inquiry *inqp;
fbd7ab3e	388
fe42625c	389	h->lun_state = RDAC_LUN_UNOWNED;
9eece961	390	h->state = RDAC_STATE_ACTIVE;
ca9f0089	391	err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
fbd7ab3e	392	if (err == SCSI_DH_OK) {
fbd7ab3e	393	inqp = &h->inq.c9;
ca9f0089 HR	394	if ((inqp->avte_cvp >> 7) == 0x1) {
	395	/* LUN in AVT mode */
	396	sdev_printk(KERN_NOTICE, sdev,
	397	"%s: AVT mode detected\n",
	398	RDAC_NAME);
	399	h->lun_state = RDAC_LUN_AVT;
	400	} else if ((inqp->avte_cvp & 0x1) != 0) {
	401	/* LUN was owned by the controller */
	402	h->lun_state = RDAC_LUN_OWNED;
	403	}
	404	}
	405
5a36756b CS	406	if (h->lun_state == RDAC_LUN_UNOWNED)
	407	h->state = RDAC_STATE_PASSIVE;
	408
fbd7ab3e CS	409	return err;
	410	}
	411
ca9f0089 HR	412	static int initialize_controller(struct scsi_device *sdev,
ca9f0089 HR	413	struct rdac_dh_data *h)
fbd7ab3e CS	414	{
	415	int err;
	416	struct c4_inquiry *inqp;
fbd7ab3e	417
ca9f0089	418	err = submit_inquiry(sdev, 0xC4, sizeof(struct c4_inquiry), h);
fbd7ab3e CS	419	if (err == SCSI_DH_OK) {
	420	inqp = &h->inq.c4;
	421	h->ctlr = get_controller(inqp->subsys_id, inqp->slot_id);
	422	if (!h->ctlr)
	423	err = SCSI_DH_RES_TEMP_UNAVAIL;
	424	}
	425	return err;
	426	}
	427
ca9f0089	428	static int set_mode_select(struct scsi_device sdev, struct rdac_dh_data h)
fbd7ab3e CS	429	{
	430	int err;
	431	struct c2_inquiry *inqp;
fbd7ab3e	432
ca9f0089	433	err = submit_inquiry(sdev, 0xC2, sizeof(struct c2_inquiry), h);
fbd7ab3e CS	434	if (err == SCSI_DH_OK) {
	435	inqp = &h->inq.c2;
	436	/*
	437	* If more than MODE6_MAX_LUN luns are supported, use
	438	* mode select 10
	439	*/
	440	if (inqp->max_lun_supported >= MODE6_MAX_LUN)
	441	h->ctlr->use_ms10 = 1;
	442	else
	443	h->ctlr->use_ms10 = 0;
	444	}
	445	return err;
	446	}
	447
ca9f0089 HR	448	static int mode_select_handle_sense(struct scsi_device *sdev,
ca9f0089 HR	449	unsigned char *sensebuf)
fbd7ab3e CS	450	{
fbd7ab3e CS	451	struct scsi_sense_hdr sense_hdr;
fbd7ab3e CS	452	int sense, err = SCSI_DH_IO, ret;
fbd7ab3e CS	453
ca9f0089	454	ret = scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE, &sense_hdr);
fbd7ab3e CS	455	if (!ret)
	456	goto done;
	457
	458	err = SCSI_DH_OK;
	459	sense = (sense_hdr.sense_key << 16) \| (sense_hdr.asc << 8) \|
	460	sense_hdr.ascq;
	461	/* If it is retryable failure, submit the c9 inquiry again */
	462	if (sense == 0x59136 \|\| sense == 0x68b02 \|\| sense == 0xb8b02 \|\|
	463	sense == 0x62900) {
	464	/* 0x59136 - Command lock contention
	465	* 0x[6b]8b02 - Quiesense in progress or achieved
	466	* 0x62900 - Power On, Reset, or Bus Device Reset
	467	*/
	468	err = SCSI_DH_RETRY;
	469	}
	470
	471	if (sense)
	472	sdev_printk(KERN_INFO, sdev,
	473	"MODE_SELECT failed with sense 0x%x.\n", sense);
	474	done:
	475	return err;
	476	}
	477
ca9f0089	478	static int send_mode_select(struct scsi_device sdev, struct rdac_dh_data h)
fbd7ab3e CS	479	{
	480	struct request *rq;
	481	struct request_queue *q = sdev->request_queue;
c85f8cb9	482	int err, retry_cnt = RDAC_RETRY_COUNT;
fbd7ab3e	483
c85f8cb9 CS	484	retry:
c85f8cb9 CS	485	err = SCSI_DH_RES_TEMP_UNAVAIL;
ca9f0089	486	rq = rdac_failover_get(sdev, h);
fbd7ab3e CS	487	if (!rq)
	488	goto done;
	489
c85f8cb9 CS	490	sdev_printk(KERN_INFO, sdev, "%s MODE_SELECT command.\n",
c85f8cb9 CS	491	(retry_cnt == RDAC_RETRY_COUNT) ? "queueing" : "retrying");
fbd7ab3e CS	492
fbd7ab3e CS	493	err = blk_execute_rq(q, NULL, rq, 1);
c85f8cb9 CS	494	blk_put_request(rq);
c85f8cb9 CS	495	if (err != SCSI_DH_OK) {
ca9f0089	496	err = mode_select_handle_sense(sdev, h->sense);
c85f8cb9 CS	497	if (err == SCSI_DH_RETRY && retry_cnt--)
	498	goto retry;
	499	}
fbd7ab3e CS	500	if (err == SCSI_DH_OK)
fbd7ab3e CS	501	h->state = RDAC_STATE_ACTIVE;
ca9f0089	502
fbd7ab3e CS	503	done:
	504	return err;
	505	}
	506
	507	static int rdac_activate(struct scsi_device *sdev)
	508	{
	509	struct rdac_dh_data *h = get_rdac_data(sdev);
	510	int err = SCSI_DH_OK;
	511
ca9f0089 HR	512	err = check_ownership(sdev, h);
ca9f0089 HR	513	if (err != SCSI_DH_OK)
fbd7ab3e	514	goto done;
fbd7ab3e CS	515
fbd7ab3e CS	516	if (!h->ctlr) {
ca9f0089	517	err = initialize_controller(sdev, h);
fbd7ab3e CS	518	if (err != SCSI_DH_OK)
	519	goto done;
	520	}
	521
	522	if (h->ctlr->use_ms10 == -1) {
ca9f0089	523	err = set_mode_select(sdev, h);
fbd7ab3e CS	524	if (err != SCSI_DH_OK)
	525	goto done;
	526	}
ca9f0089 HR	527	if (h->lun_state == RDAC_LUN_UNOWNED)
ca9f0089 HR	528	err = send_mode_select(sdev, h);
fbd7ab3e CS	529	done:
	530	return err;
	531	}
	532
	533	static int rdac_prep_fn(struct scsi_device sdev, struct request req)
	534	{
	535	struct rdac_dh_data *h = get_rdac_data(sdev);
	536	int ret = BLKPREP_OK;
	537
	538	if (h->state != RDAC_STATE_ACTIVE) {
	539	ret = BLKPREP_KILL;
	540	req->cmd_flags \|= REQ_QUIET;
	541	}
	542	return ret;
	543
	544	}
	545
	546	static int rdac_check_sense(struct scsi_device *sdev,
	547	struct scsi_sense_hdr *sense_hdr)
	548	{
	549	struct rdac_dh_data *h = get_rdac_data(sdev);
	550	switch (sense_hdr->sense_key) {
	551	case NOT_READY:
	552	if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x81)
	553	/* LUN Not Ready - Storage firmware incompatible
	554	* Manual code synchonisation required.
	555	*
	556	* Nothing we can do here. Try to bypass the path.
	557	*/
	558	return SUCCESS;
	559	if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0xA1)
	560	/* LUN Not Ready - Quiescense in progress
	561	*
	562	* Just retry and wait.
	563	*/
c7dbb627	564	return ADD_TO_MLQUEUE;
fbd7ab3e CS	565	break;
	566	case ILLEGAL_REQUEST:
	567	if (sense_hdr->asc == 0x94 && sense_hdr->ascq == 0x01) {
	568	/* Invalid Request - Current Logical Unit Ownership.
	569	* Controller is not the current owner of the LUN,
	570	* Fail the path, so that the other path be used.
	571	*/
	572	h->state = RDAC_STATE_PASSIVE;
	573	return SUCCESS;
	574	}
	575	break;
	576	case UNIT_ATTENTION:
	577	if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
	578	/*
	579	* Power On, Reset, or Bus Device Reset, just retry.
ea41e415 CV	580	*/
	581	return ADD_TO_MLQUEUE;
	582	if (sense_hdr->asc == 0x8b && sense_hdr->ascq == 0x02)
	583	/*
	584	* Quiescence in progress , just retry.
fbd7ab3e	585	*/
c7dbb627	586	return ADD_TO_MLQUEUE;
fbd7ab3e CS	587	break;
	588	}
	589	/* success just means we do not care what scsi-ml does */
	590	return SCSI_RETURN_NOT_HANDLED;
	591	}
	592
f08c0761	593	static const struct scsi_dh_devlist rdac_dev_list[] = {
fbd7ab3e CS	594	{"IBM", "1722"},
	595	{"IBM", "1724"},
	596	{"IBM", "1726"},
	597	{"IBM", "1742"},
	598	{"IBM", "1814"},
	599	{"IBM", "1815"},
	600	{"IBM", "1818"},
	601	{"IBM", "3526"},
	602	{"SGI", "TP9400"},
	603	{"SGI", "TP9500"},
	604	{"SGI", "IS"},
	605	{"STK", "OPENstorage D280"},
	606	{"SUN", "CSM200_R"},
	607	{"SUN", "LCSM100_F"},
650849d7 YD	608	{"DELL", "MD3000"},
650849d7 YD	609	{"DELL", "MD3000i"},
273c4781 BM	610	{"LSI", "INF-01-00"},
273c4781 BM	611	{"ENGENIO", "INF-01-00"},
fbd7ab3e CS	612	{NULL, NULL},
	613	};
	614
765cbc6d HR	615	static int rdac_bus_attach(struct scsi_device *sdev);
765cbc6d HR	616	static void rdac_bus_detach(struct scsi_device *sdev);
fbd7ab3e CS	617
	618	static struct scsi_device_handler rdac_dh = {
	619	.name = RDAC_NAME,
	620	.module = THIS_MODULE,
765cbc6d	621	.devlist = rdac_dev_list,
fbd7ab3e CS	622	.prep_fn = rdac_prep_fn,
fbd7ab3e CS	623	.check_sense = rdac_check_sense,
765cbc6d HR	624	.attach = rdac_bus_attach,
765cbc6d HR	625	.detach = rdac_bus_detach,
fbd7ab3e CS	626	.activate = rdac_activate,
	627	};
	628
765cbc6d	629	static int rdac_bus_attach(struct scsi_device *sdev)
fbd7ab3e	630	{
fbd7ab3e CS	631	struct scsi_dh_data *scsi_dh_data;
fbd7ab3e CS	632	struct rdac_dh_data *h;
fbd7ab3e	633	unsigned long flags;
ca9f0089	634	int err;
fbd7ab3e	635
765cbc6d HR	636	scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
	637	+ sizeof(*h) , GFP_KERNEL);
	638	if (!scsi_dh_data) {
ca9f0089	639	sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
765cbc6d	640	RDAC_NAME);
33af79d1	641	return 0;
765cbc6d	642	}
33af79d1	643
765cbc6d HR	644	scsi_dh_data->scsi_dh = &rdac_dh;
	645	h = (struct rdac_dh_data *) scsi_dh_data->buf;
	646	h->lun = UNINITIALIZED_LUN;
	647	h->state = RDAC_STATE_ACTIVE;
ca9f0089 HR	648
	649	err = get_lun(sdev, h);
	650	if (err != SCSI_DH_OK)
	651	goto failed;
	652
	653	err = check_ownership(sdev, h);
	654	if (err != SCSI_DH_OK)
	655	goto failed;
	656
	657	if (!try_module_get(THIS_MODULE))
	658	goto failed;
	659
765cbc6d HR	660	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
	661	sdev->scsi_dh_data = scsi_dh_data;
	662	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
fbd7ab3e	663
ca9f0089 HR	664	sdev_printk(KERN_NOTICE, sdev,
	665	"%s: LUN %d (%s)\n",
	666	RDAC_NAME, h->lun, lun_state[(int)h->lun_state]);
fbd7ab3e	667
fbd7ab3e	668	return 0;
ca9f0089 HR	669
	670	failed:
	671	kfree(scsi_dh_data);
	672	sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
	673	RDAC_NAME);
	674	return -EINVAL;
fbd7ab3e CS	675	}
fbd7ab3e CS	676
765cbc6d HR	677	static void rdac_bus_detach( struct scsi_device *sdev )
	678	{
	679	struct scsi_dh_data *scsi_dh_data;
	680	struct rdac_dh_data *h;
	681	unsigned long flags;
	682
	683	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
	684	scsi_dh_data = sdev->scsi_dh_data;
	685	sdev->scsi_dh_data = NULL;
	686	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
	687
	688	h = (struct rdac_dh_data *) scsi_dh_data->buf;
	689	if (h->ctlr)
	690	kref_put(&h->ctlr->kref, release_controller);
	691	kfree(scsi_dh_data);
	692	module_put(THIS_MODULE);
ca9f0089	693	sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", RDAC_NAME);
765cbc6d HR	694	}
	695
	696
	697
fbd7ab3e CS	698	static int __init rdac_init(void)
	699	{
	700	int r;
	701
	702	r = scsi_register_device_handler(&rdac_dh);
	703	if (r != 0)
	704	printk(KERN_ERR "Failed to register scsi device handler.");
	705	return r;
	706	}
	707
	708	static void __exit rdac_exit(void)
	709	{
	710	scsi_unregister_device_handler(&rdac_dh);
	711	}
	712
	713	module_init(rdac_init);
	714	module_exit(rdac_exit);
	715
	716	MODULE_DESCRIPTION("Multipath LSI/Engenio RDAC driver");
	717	MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
	718	MODULE_LICENSE("GPL");