1 /*
2  * LSI/Engenio/NetApp E-Series 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 #include <linux/workqueue.h>
26 #include <linux/slab.h>
27 #include <linux/module.h>
28 
29 #define RDAC_NAME "rdac"
30 #define RDAC_RETRY_COUNT 5
31 
32 /*
33  * LSI mode page stuff
34  *
35  * These struct definitions and the forming of the
36  * mode page were taken from the LSI RDAC 2.4 GPL'd
37  * driver, and then converted to Linux conventions.
38  */
39 #define RDAC_QUIESCENCE_TIME 20
40 /*
41  * Page Codes
42  */
43 #define RDAC_PAGE_CODE_REDUNDANT_CONTROLLER 0x2c
44 
45 /*
46  * Controller modes definitions
47  */
48 #define RDAC_MODE_TRANSFER_SPECIFIED_LUNS	0x02
49 
50 /*
51  * RDAC Options field
52  */
53 #define RDAC_FORCED_QUIESENCE 0x02
54 
55 #define RDAC_TIMEOUT	(60 * HZ)
56 #define RDAC_RETRIES	3
57 
58 struct rdac_mode_6_hdr {
59 	u8	data_len;
60 	u8	medium_type;
61 	u8	device_params;
62 	u8	block_desc_len;
63 };
64 
65 struct rdac_mode_10_hdr {
66 	u16	data_len;
67 	u8	medium_type;
68 	u8	device_params;
69 	u16	reserved;
70 	u16	block_desc_len;
71 };
72 
73 struct rdac_mode_common {
74 	u8	controller_serial[16];
75 	u8	alt_controller_serial[16];
76 	u8	rdac_mode[2];
77 	u8	alt_rdac_mode[2];
78 	u8	quiescence_timeout;
79 	u8	rdac_options;
80 };
81 
82 struct rdac_pg_legacy {
83 	struct rdac_mode_6_hdr hdr;
84 	u8	page_code;
85 	u8	page_len;
86 	struct rdac_mode_common common;
87 #define MODE6_MAX_LUN	32
88 	u8	lun_table[MODE6_MAX_LUN];
89 	u8	reserved2[32];
90 	u8	reserved3;
91 	u8	reserved4;
92 };
93 
94 struct rdac_pg_expanded {
95 	struct rdac_mode_10_hdr hdr;
96 	u8	page_code;
97 	u8	subpage_code;
98 	u8	page_len[2];
99 	struct rdac_mode_common common;
100 	u8	lun_table[256];
101 	u8	reserved3;
102 	u8	reserved4;
103 };
104 
105 struct c9_inquiry {
106 	u8	peripheral_info;
107 	u8	page_code;	/* 0xC9 */
108 	u8	reserved1;
109 	u8	page_len;
110 	u8	page_id[4];	/* "vace" */
111 	u8	avte_cvp;
112 	u8	path_prio;
113 	u8	reserved2[38];
114 };
115 
116 #define SUBSYS_ID_LEN	16
117 #define SLOT_ID_LEN	2
118 #define ARRAY_LABEL_LEN	31
119 
120 struct c4_inquiry {
121 	u8	peripheral_info;
122 	u8	page_code;	/* 0xC4 */
123 	u8	reserved1;
124 	u8	page_len;
125 	u8	page_id[4];	/* "subs" */
126 	u8	subsys_id[SUBSYS_ID_LEN];
127 	u8	revision[4];
128 	u8	slot_id[SLOT_ID_LEN];
129 	u8	reserved[2];
130 };
131 
132 #define UNIQUE_ID_LEN 16
133 struct c8_inquiry {
134 	u8	peripheral_info;
135 	u8	page_code; /* 0xC8 */
136 	u8	reserved1;
137 	u8	page_len;
138 	u8	page_id[4]; /* "edid" */
139 	u8	reserved2[3];
140 	u8	vol_uniq_id_len;
141 	u8	vol_uniq_id[16];
142 	u8	vol_user_label_len;
143 	u8	vol_user_label[60];
144 	u8	array_uniq_id_len;
145 	u8	array_unique_id[UNIQUE_ID_LEN];
146 	u8	array_user_label_len;
147 	u8	array_user_label[60];
148 	u8	lun[8];
149 };
150 
151 struct rdac_controller {
152 	u8			array_id[UNIQUE_ID_LEN];
153 	int			use_ms10;
154 	struct kref		kref;
155 	struct list_head	node; /* list of all controllers */
156 	union			{
157 		struct rdac_pg_legacy legacy;
158 		struct rdac_pg_expanded expanded;
159 	} mode_select;
160 	u8	index;
161 	u8	array_name[ARRAY_LABEL_LEN];
162 	struct Scsi_Host	*host;
163 	spinlock_t		ms_lock;
164 	int			ms_queued;
165 	struct work_struct	ms_work;
166 	struct scsi_device	*ms_sdev;
167 	struct list_head	ms_head;
168 };
169 
170 struct c2_inquiry {
171 	u8	peripheral_info;
172 	u8	page_code;	/* 0xC2 */
173 	u8	reserved1;
174 	u8	page_len;
175 	u8	page_id[4];	/* "swr4" */
176 	u8	sw_version[3];
177 	u8	sw_date[3];
178 	u8	features_enabled;
179 	u8	max_lun_supported;
180 	u8	partitions[239]; /* Total allocation length should be 0xFF */
181 };
182 
183 struct rdac_dh_data {
184 	struct rdac_controller	*ctlr;
185 #define UNINITIALIZED_LUN	(1 << 8)
186 	unsigned		lun;
187 
188 #define RDAC_MODE		0
189 #define RDAC_MODE_AVT		1
190 #define RDAC_MODE_IOSHIP	2
191 	unsigned char		mode;
192 
193 #define RDAC_STATE_ACTIVE	0
194 #define RDAC_STATE_PASSIVE	1
195 	unsigned char		state;
196 
197 #define RDAC_LUN_UNOWNED	0
198 #define RDAC_LUN_OWNED		1
199 	char			lun_state;
200 
201 #define RDAC_PREFERRED		0
202 #define RDAC_NON_PREFERRED	1
203 	char			preferred;
204 
205 	unsigned char		sense[SCSI_SENSE_BUFFERSIZE];
206 	union			{
207 		struct c2_inquiry c2;
208 		struct c4_inquiry c4;
209 		struct c8_inquiry c8;
210 		struct c9_inquiry c9;
211 	} inq;
212 };
213 
214 static const char *mode[] = {
215 	"RDAC",
216 	"AVT",
217 	"IOSHIP",
218 };
219 static const char *lun_state[] =
220 {
221 	"unowned",
222 	"owned",
223 };
224 
225 struct rdac_queue_data {
226 	struct list_head	entry;
227 	struct rdac_dh_data	*h;
228 	activate_complete	callback_fn;
229 	void			*callback_data;
230 };
231 
232 static LIST_HEAD(ctlr_list);
233 static DEFINE_SPINLOCK(list_lock);
234 static struct workqueue_struct *kmpath_rdacd;
235 static void send_mode_select(struct work_struct *work);
236 
237 /*
238  * module parameter to enable rdac debug logging.
239  * 2 bits for each type of logging, only two types defined for now
240  * Can be enhanced if required at later point
241  */
242 static int rdac_logging = 1;
243 module_param(rdac_logging, int, S_IRUGO|S_IWUSR);
244 MODULE_PARM_DESC(rdac_logging, "A bit mask of rdac logging levels, "
245 		"Default is 1 - failover logging enabled, "
246 		"set it to 0xF to enable all the logs");
247 
248 #define RDAC_LOG_FAILOVER	0
249 #define RDAC_LOG_SENSE		2
250 
251 #define RDAC_LOG_BITS		2
252 
253 #define RDAC_LOG_LEVEL(SHIFT)  \
254 	((rdac_logging >> (SHIFT)) & ((1 << (RDAC_LOG_BITS)) - 1))
255 
256 #define RDAC_LOG(SHIFT, sdev, f, arg...) \
257 do { \
258 	if (unlikely(RDAC_LOG_LEVEL(SHIFT))) \
259 		sdev_printk(KERN_INFO, sdev, RDAC_NAME ": " f "\n", ## arg); \
260 } while (0);
261 
262 static inline struct rdac_dh_data *get_rdac_data(struct scsi_device *sdev)
263 {
264 	struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
265 	BUG_ON(scsi_dh_data == NULL);
266 	return ((struct rdac_dh_data *) scsi_dh_data->buf);
267 }
268 
269 static struct request *get_rdac_req(struct scsi_device *sdev,
270 			void *buffer, unsigned buflen, int rw)
271 {
272 	struct request *rq;
273 	struct request_queue *q = sdev->request_queue;
274 
275 	rq = blk_get_request(q, rw, GFP_NOIO);
276 
277 	if (IS_ERR(rq)) {
278 		sdev_printk(KERN_INFO, sdev,
279 				"get_rdac_req: blk_get_request failed.\n");
280 		return NULL;
281 	}
282 	blk_rq_set_block_pc(rq);
283 
284 	if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
285 		blk_put_request(rq);
286 		sdev_printk(KERN_INFO, sdev,
287 				"get_rdac_req: blk_rq_map_kern failed.\n");
288 		return NULL;
289 	}
290 
291 	rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
292 			 REQ_FAILFAST_DRIVER;
293 	rq->retries = RDAC_RETRIES;
294 	rq->timeout = RDAC_TIMEOUT;
295 
296 	return rq;
297 }
298 
299 static struct request *rdac_failover_get(struct scsi_device *sdev,
300 			struct rdac_dh_data *h, struct list_head *list)
301 {
302 	struct request *rq;
303 	struct rdac_mode_common *common;
304 	unsigned data_size;
305 	struct rdac_queue_data *qdata;
306 	u8 *lun_table;
307 
308 	if (h->ctlr->use_ms10) {
309 		struct rdac_pg_expanded *rdac_pg;
310 
311 		data_size = sizeof(struct rdac_pg_expanded);
312 		rdac_pg = &h->ctlr->mode_select.expanded;
313 		memset(rdac_pg, 0, data_size);
314 		common = &rdac_pg->common;
315 		rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER + 0x40;
316 		rdac_pg->subpage_code = 0x1;
317 		rdac_pg->page_len[0] = 0x01;
318 		rdac_pg->page_len[1] = 0x28;
319 		lun_table = rdac_pg->lun_table;
320 	} else {
321 		struct rdac_pg_legacy *rdac_pg;
322 
323 		data_size = sizeof(struct rdac_pg_legacy);
324 		rdac_pg = &h->ctlr->mode_select.legacy;
325 		memset(rdac_pg, 0, data_size);
326 		common = &rdac_pg->common;
327 		rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER;
328 		rdac_pg->page_len = 0x68;
329 		lun_table = rdac_pg->lun_table;
330 	}
331 	common->rdac_mode[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS;
332 	common->quiescence_timeout = RDAC_QUIESCENCE_TIME;
333 	common->rdac_options = RDAC_FORCED_QUIESENCE;
334 
335 	list_for_each_entry(qdata, list, entry) {
336 		lun_table[qdata->h->lun] = 0x81;
337 	}
338 
339 	/* get request for block layer packet command */
340 	rq = get_rdac_req(sdev, &h->ctlr->mode_select, data_size, WRITE);
341 	if (!rq)
342 		return NULL;
343 
344 	/* Prepare the command. */
345 	if (h->ctlr->use_ms10) {
346 		rq->cmd[0] = MODE_SELECT_10;
347 		rq->cmd[7] = data_size >> 8;
348 		rq->cmd[8] = data_size & 0xff;
349 	} else {
350 		rq->cmd[0] = MODE_SELECT;
351 		rq->cmd[4] = data_size;
352 	}
353 	rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
354 
355 	rq->sense = h->sense;
356 	memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
357 	rq->sense_len = 0;
358 
359 	return rq;
360 }
361 
362 static void release_controller(struct kref *kref)
363 {
364 	struct rdac_controller *ctlr;
365 	ctlr = container_of(kref, struct rdac_controller, kref);
366 
367 	list_del(&ctlr->node);
368 	kfree(ctlr);
369 }
370 
371 static struct rdac_controller *get_controller(int index, char *array_name,
372 			u8 *array_id, struct scsi_device *sdev)
373 {
374 	struct rdac_controller *ctlr, *tmp;
375 
376 	list_for_each_entry(tmp, &ctlr_list, node) {
377 		if ((memcmp(tmp->array_id, array_id, UNIQUE_ID_LEN) == 0) &&
378 			  (tmp->index == index) &&
379 			  (tmp->host == sdev->host)) {
380 			kref_get(&tmp->kref);
381 			return tmp;
382 		}
383 	}
384 	ctlr = kmalloc(sizeof(*ctlr), GFP_ATOMIC);
385 	if (!ctlr)
386 		return NULL;
387 
388 	/* initialize fields of controller */
389 	memcpy(ctlr->array_id, array_id, UNIQUE_ID_LEN);
390 	ctlr->index = index;
391 	ctlr->host = sdev->host;
392 	memcpy(ctlr->array_name, array_name, ARRAY_LABEL_LEN);
393 
394 	kref_init(&ctlr->kref);
395 	ctlr->use_ms10 = -1;
396 	ctlr->ms_queued = 0;
397 	ctlr->ms_sdev = NULL;
398 	spin_lock_init(&ctlr->ms_lock);
399 	INIT_WORK(&ctlr->ms_work, send_mode_select);
400 	INIT_LIST_HEAD(&ctlr->ms_head);
401 	list_add(&ctlr->node, &ctlr_list);
402 
403 	return ctlr;
404 }
405 
406 static int submit_inquiry(struct scsi_device *sdev, int page_code,
407 			  unsigned int len, struct rdac_dh_data *h)
408 {
409 	struct request *rq;
410 	struct request_queue *q = sdev->request_queue;
411 	int err = SCSI_DH_RES_TEMP_UNAVAIL;
412 
413 	rq = get_rdac_req(sdev, &h->inq, len, READ);
414 	if (!rq)
415 		goto done;
416 
417 	/* Prepare the command. */
418 	rq->cmd[0] = INQUIRY;
419 	rq->cmd[1] = 1;
420 	rq->cmd[2] = page_code;
421 	rq->cmd[4] = len;
422 	rq->cmd_len = COMMAND_SIZE(INQUIRY);
423 
424 	rq->sense = h->sense;
425 	memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
426 	rq->sense_len = 0;
427 
428 	err = blk_execute_rq(q, NULL, rq, 1);
429 	if (err == -EIO)
430 		err = SCSI_DH_IO;
431 
432 	blk_put_request(rq);
433 done:
434 	return err;
435 }
436 
437 static int get_lun_info(struct scsi_device *sdev, struct rdac_dh_data *h,
438 			char *array_name, u8 *array_id)
439 {
440 	int err, i;
441 	struct c8_inquiry *inqp;
442 
443 	err = submit_inquiry(sdev, 0xC8, sizeof(struct c8_inquiry), h);
444 	if (err == SCSI_DH_OK) {
445 		inqp = &h->inq.c8;
446 		if (inqp->page_code != 0xc8)
447 			return SCSI_DH_NOSYS;
448 		if (inqp->page_id[0] != 'e' || inqp->page_id[1] != 'd' ||
449 		    inqp->page_id[2] != 'i' || inqp->page_id[3] != 'd')
450 			return SCSI_DH_NOSYS;
451 		h->lun = inqp->lun[7]; /* Uses only the last byte */
452 
453 		for(i=0; i<ARRAY_LABEL_LEN-1; ++i)
454 			*(array_name+i) = inqp->array_user_label[(2*i)+1];
455 
456 		*(array_name+ARRAY_LABEL_LEN-1) = '\0';
457 		memset(array_id, 0, UNIQUE_ID_LEN);
458 		memcpy(array_id, inqp->array_unique_id, inqp->array_uniq_id_len);
459 	}
460 	return err;
461 }
462 
463 static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
464 {
465 	int err;
466 	struct c9_inquiry *inqp;
467 
468 	h->state = RDAC_STATE_ACTIVE;
469 	err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
470 	if (err == SCSI_DH_OK) {
471 		inqp = &h->inq.c9;
472 		/* detect the operating mode */
473 		if ((inqp->avte_cvp >> 5) & 0x1)
474 			h->mode = RDAC_MODE_IOSHIP; /* LUN in IOSHIP mode */
475 		else if (inqp->avte_cvp >> 7)
476 			h->mode = RDAC_MODE_AVT; /* LUN in AVT mode */
477 		else
478 			h->mode = RDAC_MODE; /* LUN in RDAC mode */
479 
480 		/* Update ownership */
481 		if (inqp->avte_cvp & 0x1)
482 			h->lun_state = RDAC_LUN_OWNED;
483 		else {
484 			h->lun_state = RDAC_LUN_UNOWNED;
485 			if (h->mode == RDAC_MODE)
486 				h->state = RDAC_STATE_PASSIVE;
487 		}
488 
489 		/* Update path prio*/
490 		if (inqp->path_prio & 0x1)
491 			h->preferred = RDAC_PREFERRED;
492 		else
493 			h->preferred = RDAC_NON_PREFERRED;
494 	}
495 
496 	return err;
497 }
498 
499 static int initialize_controller(struct scsi_device *sdev,
500 		struct rdac_dh_data *h, char *array_name, u8 *array_id)
501 {
502 	int err, index;
503 	struct c4_inquiry *inqp;
504 
505 	err = submit_inquiry(sdev, 0xC4, sizeof(struct c4_inquiry), h);
506 	if (err == SCSI_DH_OK) {
507 		inqp = &h->inq.c4;
508 		/* get the controller index */
509 		if (inqp->slot_id[1] == 0x31)
510 			index = 0;
511 		else
512 			index = 1;
513 
514 		spin_lock(&list_lock);
515 		h->ctlr = get_controller(index, array_name, array_id, sdev);
516 		if (!h->ctlr)
517 			err = SCSI_DH_RES_TEMP_UNAVAIL;
518 		spin_unlock(&list_lock);
519 	}
520 	return err;
521 }
522 
523 static int set_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
524 {
525 	int err;
526 	struct c2_inquiry *inqp;
527 
528 	err = submit_inquiry(sdev, 0xC2, sizeof(struct c2_inquiry), h);
529 	if (err == SCSI_DH_OK) {
530 		inqp = &h->inq.c2;
531 		/*
532 		 * If more than MODE6_MAX_LUN luns are supported, use
533 		 * mode select 10
534 		 */
535 		if (inqp->max_lun_supported >= MODE6_MAX_LUN)
536 			h->ctlr->use_ms10 = 1;
537 		else
538 			h->ctlr->use_ms10 = 0;
539 	}
540 	return err;
541 }
542 
543 static int mode_select_handle_sense(struct scsi_device *sdev,
544 					unsigned char *sensebuf)
545 {
546 	struct scsi_sense_hdr sense_hdr;
547 	int err = SCSI_DH_IO, ret;
548 	struct rdac_dh_data *h = get_rdac_data(sdev);
549 
550 	ret = scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE, &sense_hdr);
551 	if (!ret)
552 		goto done;
553 
554 	switch (sense_hdr.sense_key) {
555 	case NO_SENSE:
556 	case ABORTED_COMMAND:
557 	case UNIT_ATTENTION:
558 		err = SCSI_DH_RETRY;
559 		break;
560 	case NOT_READY:
561 		if (sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x01)
562 			/* LUN Not Ready and is in the Process of Becoming
563 			 * Ready
564 			 */
565 			err = SCSI_DH_RETRY;
566 		break;
567 	case ILLEGAL_REQUEST:
568 		if (sense_hdr.asc == 0x91 && sense_hdr.ascq == 0x36)
569 			/*
570 			 * Command Lock contention
571 			 */
572 			err = SCSI_DH_RETRY;
573 		break;
574 	default:
575 		break;
576 	}
577 
578 	RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
579 		"MODE_SELECT returned with sense %02x/%02x/%02x",
580 		(char *) h->ctlr->array_name, h->ctlr->index,
581 		sense_hdr.sense_key, sense_hdr.asc, sense_hdr.ascq);
582 
583 done:
584 	return err;
585 }
586 
587 static void send_mode_select(struct work_struct *work)
588 {
589 	struct rdac_controller *ctlr =
590 		container_of(work, struct rdac_controller, ms_work);
591 	struct request *rq;
592 	struct scsi_device *sdev = ctlr->ms_sdev;
593 	struct rdac_dh_data *h = get_rdac_data(sdev);
594 	struct request_queue *q = sdev->request_queue;
595 	int err, retry_cnt = RDAC_RETRY_COUNT;
596 	struct rdac_queue_data *tmp, *qdata;
597 	LIST_HEAD(list);
598 
599 	spin_lock(&ctlr->ms_lock);
600 	list_splice_init(&ctlr->ms_head, &list);
601 	ctlr->ms_queued = 0;
602 	ctlr->ms_sdev = NULL;
603 	spin_unlock(&ctlr->ms_lock);
604 
605 retry:
606 	err = SCSI_DH_RES_TEMP_UNAVAIL;
607 	rq = rdac_failover_get(sdev, h, &list);
608 	if (!rq)
609 		goto done;
610 
611 	RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
612 		"%s MODE_SELECT command",
613 		(char *) h->ctlr->array_name, h->ctlr->index,
614 		(retry_cnt == RDAC_RETRY_COUNT) ? "queueing" : "retrying");
615 
616 	err = blk_execute_rq(q, NULL, rq, 1);
617 	blk_put_request(rq);
618 	if (err != SCSI_DH_OK) {
619 		err = mode_select_handle_sense(sdev, h->sense);
620 		if (err == SCSI_DH_RETRY && retry_cnt--)
621 			goto retry;
622 	}
623 	if (err == SCSI_DH_OK) {
624 		h->state = RDAC_STATE_ACTIVE;
625 		RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
626 				"MODE_SELECT completed",
627 				(char *) h->ctlr->array_name, h->ctlr->index);
628 	}
629 
630 done:
631 	list_for_each_entry_safe(qdata, tmp, &list, entry) {
632 		list_del(&qdata->entry);
633 		if (err == SCSI_DH_OK)
634 			qdata->h->state = RDAC_STATE_ACTIVE;
635 		if (qdata->callback_fn)
636 			qdata->callback_fn(qdata->callback_data, err);
637 		kfree(qdata);
638 	}
639 	return;
640 }
641 
642 static int queue_mode_select(struct scsi_device *sdev,
643 				activate_complete fn, void *data)
644 {
645 	struct rdac_queue_data *qdata;
646 	struct rdac_controller *ctlr;
647 
648 	qdata = kzalloc(sizeof(*qdata), GFP_KERNEL);
649 	if (!qdata)
650 		return SCSI_DH_RETRY;
651 
652 	qdata->h = get_rdac_data(sdev);
653 	qdata->callback_fn = fn;
654 	qdata->callback_data = data;
655 
656 	ctlr = qdata->h->ctlr;
657 	spin_lock(&ctlr->ms_lock);
658 	list_add_tail(&qdata->entry, &ctlr->ms_head);
659 	if (!ctlr->ms_queued) {
660 		ctlr->ms_queued = 1;
661 		ctlr->ms_sdev = sdev;
662 		queue_work(kmpath_rdacd, &ctlr->ms_work);
663 	}
664 	spin_unlock(&ctlr->ms_lock);
665 	return SCSI_DH_OK;
666 }
667 
668 static int rdac_activate(struct scsi_device *sdev,
669 			activate_complete fn, void *data)
670 {
671 	struct rdac_dh_data *h = get_rdac_data(sdev);
672 	int err = SCSI_DH_OK;
673 	int act = 0;
674 
675 	err = check_ownership(sdev, h);
676 	if (err != SCSI_DH_OK)
677 		goto done;
678 
679 	switch (h->mode) {
680 	case RDAC_MODE:
681 		if (h->lun_state == RDAC_LUN_UNOWNED)
682 			act = 1;
683 		break;
684 	case RDAC_MODE_IOSHIP:
685 		if ((h->lun_state == RDAC_LUN_UNOWNED) &&
686 		    (h->preferred == RDAC_PREFERRED))
687 			act = 1;
688 		break;
689 	default:
690 		break;
691 	}
692 
693 	if (act) {
694 		err = queue_mode_select(sdev, fn, data);
695 		if (err == SCSI_DH_OK)
696 			return 0;
697 	}
698 done:
699 	if (fn)
700 		fn(data, err);
701 	return 0;
702 }
703 
704 static int rdac_prep_fn(struct scsi_device *sdev, struct request *req)
705 {
706 	struct rdac_dh_data *h = get_rdac_data(sdev);
707 	int ret = BLKPREP_OK;
708 
709 	if (h->state != RDAC_STATE_ACTIVE) {
710 		ret = BLKPREP_KILL;
711 		req->cmd_flags |= REQ_QUIET;
712 	}
713 	return ret;
714 
715 }
716 
717 static int rdac_check_sense(struct scsi_device *sdev,
718 				struct scsi_sense_hdr *sense_hdr)
719 {
720 	struct rdac_dh_data *h = get_rdac_data(sdev);
721 
722 	RDAC_LOG(RDAC_LOG_SENSE, sdev, "array %s, ctlr %d, "
723 			"I/O returned with sense %02x/%02x/%02x",
724 			(char *) h->ctlr->array_name, h->ctlr->index,
725 			sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
726 
727 	switch (sense_hdr->sense_key) {
728 	case NOT_READY:
729 		if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x01)
730 			/* LUN Not Ready - Logical Unit Not Ready and is in
731 			* the process of becoming ready
732 			* Just retry.
733 			*/
734 			return ADD_TO_MLQUEUE;
735 		if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x81)
736 			/* LUN Not Ready - Storage firmware incompatible
737 			 * Manual code synchonisation required.
738 			 *
739 			 * Nothing we can do here. Try to bypass the path.
740 			 */
741 			return SUCCESS;
742 		if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0xA1)
743 			/* LUN Not Ready - Quiescense in progress
744 			 *
745 			 * Just retry and wait.
746 			 */
747 			return ADD_TO_MLQUEUE;
748 		if (sense_hdr->asc == 0xA1  && sense_hdr->ascq == 0x02)
749 			/* LUN Not Ready - Quiescense in progress
750 			 * or has been achieved
751 			 * Just retry.
752 			 */
753 			return ADD_TO_MLQUEUE;
754 		break;
755 	case ILLEGAL_REQUEST:
756 		if (sense_hdr->asc == 0x94 && sense_hdr->ascq == 0x01) {
757 			/* Invalid Request - Current Logical Unit Ownership.
758 			 * Controller is not the current owner of the LUN,
759 			 * Fail the path, so that the other path be used.
760 			 */
761 			h->state = RDAC_STATE_PASSIVE;
762 			return SUCCESS;
763 		}
764 		break;
765 	case UNIT_ATTENTION:
766 		if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
767 			/*
768 			 * Power On, Reset, or Bus Device Reset, just retry.
769 			 */
770 			return ADD_TO_MLQUEUE;
771 		if (sense_hdr->asc == 0x8b && sense_hdr->ascq == 0x02)
772 			/*
773 			 * Quiescence in progress , just retry.
774 			 */
775 			return ADD_TO_MLQUEUE;
776 		break;
777 	}
778 	/* success just means we do not care what scsi-ml does */
779 	return SCSI_RETURN_NOT_HANDLED;
780 }
781 
782 static const struct scsi_dh_devlist rdac_dev_list[] = {
783 	{"IBM", "1722"},
784 	{"IBM", "1724"},
785 	{"IBM", "1726"},
786 	{"IBM", "1742"},
787 	{"IBM", "1745"},
788 	{"IBM", "1746"},
789 	{"IBM", "1813"},
790 	{"IBM", "1814"},
791 	{"IBM", "1815"},
792 	{"IBM", "1818"},
793 	{"IBM", "3526"},
794 	{"SGI", "TP9"},
795 	{"SGI", "IS"},
796 	{"STK", "OPENstorage D280"},
797 	{"STK", "FLEXLINE 380"},
798 	{"SUN", "CSM"},
799 	{"SUN", "LCSM100"},
800 	{"SUN", "STK6580_6780"},
801 	{"SUN", "SUN_6180"},
802 	{"SUN", "ArrayStorage"},
803 	{"DELL", "MD3"},
804 	{"NETAPP", "INF-01-00"},
805 	{"LSI", "INF-01-00"},
806 	{"ENGENIO", "INF-01-00"},
807 	{NULL, NULL},
808 };
809 
810 static bool rdac_match(struct scsi_device *sdev)
811 {
812 	int i;
813 
814 	if (scsi_device_tpgs(sdev))
815 		return false;
816 
817 	for (i = 0; rdac_dev_list[i].vendor; i++) {
818 		if (!strncmp(sdev->vendor, rdac_dev_list[i].vendor,
819 			strlen(rdac_dev_list[i].vendor)) &&
820 		    !strncmp(sdev->model, rdac_dev_list[i].model,
821 			strlen(rdac_dev_list[i].model))) {
822 			return true;
823 		}
824 	}
825 	return false;
826 }
827 
828 static int rdac_bus_attach(struct scsi_device *sdev);
829 static void rdac_bus_detach(struct scsi_device *sdev);
830 
831 static struct scsi_device_handler rdac_dh = {
832 	.name = RDAC_NAME,
833 	.module = THIS_MODULE,
834 	.devlist = rdac_dev_list,
835 	.prep_fn = rdac_prep_fn,
836 	.check_sense = rdac_check_sense,
837 	.attach = rdac_bus_attach,
838 	.detach = rdac_bus_detach,
839 	.activate = rdac_activate,
840 	.match = rdac_match,
841 };
842 
843 static int rdac_bus_attach(struct scsi_device *sdev)
844 {
845 	struct scsi_dh_data *scsi_dh_data;
846 	struct rdac_dh_data *h;
847 	unsigned long flags;
848 	int err;
849 	char array_name[ARRAY_LABEL_LEN];
850 	char array_id[UNIQUE_ID_LEN];
851 
852 	scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
853 			       + sizeof(*h) , GFP_KERNEL);
854 	if (!scsi_dh_data) {
855 		sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
856 			    RDAC_NAME);
857 		return -ENOMEM;
858 	}
859 
860 	scsi_dh_data->scsi_dh = &rdac_dh;
861 	h = (struct rdac_dh_data *) scsi_dh_data->buf;
862 	h->lun = UNINITIALIZED_LUN;
863 	h->state = RDAC_STATE_ACTIVE;
864 
865 	err = get_lun_info(sdev, h, array_name, array_id);
866 	if (err != SCSI_DH_OK)
867 		goto failed;
868 
869 	err = initialize_controller(sdev, h, array_name, array_id);
870 	if (err != SCSI_DH_OK)
871 		goto failed;
872 
873 	err = check_ownership(sdev, h);
874 	if (err != SCSI_DH_OK)
875 		goto clean_ctlr;
876 
877 	err = set_mode_select(sdev, h);
878 	if (err != SCSI_DH_OK)
879 		goto clean_ctlr;
880 
881 	if (!try_module_get(THIS_MODULE))
882 		goto clean_ctlr;
883 
884 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
885 	sdev->scsi_dh_data = scsi_dh_data;
886 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
887 
888 	sdev_printk(KERN_NOTICE, sdev,
889 		    "%s: LUN %d (%s) (%s)\n",
890 		    RDAC_NAME, h->lun, mode[(int)h->mode],
891 		    lun_state[(int)h->lun_state]);
892 
893 	return 0;
894 
895 clean_ctlr:
896 	spin_lock(&list_lock);
897 	kref_put(&h->ctlr->kref, release_controller);
898 	spin_unlock(&list_lock);
899 
900 failed:
901 	kfree(scsi_dh_data);
902 	sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
903 		    RDAC_NAME);
904 	return -EINVAL;
905 }
906 
907 static void rdac_bus_detach( struct scsi_device *sdev )
908 {
909 	struct scsi_dh_data *scsi_dh_data;
910 	struct rdac_dh_data *h;
911 	unsigned long flags;
912 
913 	scsi_dh_data = sdev->scsi_dh_data;
914 	h = (struct rdac_dh_data *) scsi_dh_data->buf;
915 	if (h->ctlr && h->ctlr->ms_queued)
916 		flush_workqueue(kmpath_rdacd);
917 
918 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
919 	sdev->scsi_dh_data = NULL;
920 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
921 
922 	spin_lock(&list_lock);
923 	if (h->ctlr)
924 		kref_put(&h->ctlr->kref, release_controller);
925 	spin_unlock(&list_lock);
926 	kfree(scsi_dh_data);
927 	module_put(THIS_MODULE);
928 	sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", RDAC_NAME);
929 }
930 
931 
932 
933 static int __init rdac_init(void)
934 {
935 	int r;
936 
937 	r = scsi_register_device_handler(&rdac_dh);
938 	if (r != 0) {
939 		printk(KERN_ERR "Failed to register scsi device handler.");
940 		goto done;
941 	}
942 
943 	/*
944 	 * Create workqueue to handle mode selects for rdac
945 	 */
946 	kmpath_rdacd = create_singlethread_workqueue("kmpath_rdacd");
947 	if (!kmpath_rdacd) {
948 		scsi_unregister_device_handler(&rdac_dh);
949 		printk(KERN_ERR "kmpath_rdacd creation failed.\n");
950 
951 		r = -EINVAL;
952 	}
953 done:
954 	return r;
955 }
956 
957 static void __exit rdac_exit(void)
958 {
959 	destroy_workqueue(kmpath_rdacd);
960 	scsi_unregister_device_handler(&rdac_dh);
961 }
962 
963 module_init(rdac_init);
964 module_exit(rdac_exit);
965 
966 MODULE_DESCRIPTION("Multipath LSI/Engenio/NetApp E-Series RDAC driver");
967 MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
968 MODULE_VERSION("01.00.0000.0000");
969 MODULE_LICENSE("GPL");
970