2 * Engenio/LSI RDAC SCSI Device Handler
4 * Copyright (C) 2005 Mike Christie. All rights reserved.
5 * Copyright (C) Chandra Seetharaman, IBM Corp. 2007
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.
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.
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.
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>
29 #define RDAC_NAME "rdac"
30 #define RDAC_RETRY_COUNT 5
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.
39 #define RDAC_QUIESCENCE_TIME 20
43 #define RDAC_PAGE_CODE_REDUNDANT_CONTROLLER 0x2c
46 * Controller modes definitions
48 #define RDAC_MODE_TRANSFER_SPECIFIED_LUNS 0x02
53 #define RDAC_FORCED_QUIESENCE 0x02
55 #define RDAC_TIMEOUT (60 * HZ)
56 #define RDAC_RETRIES 3
58 struct rdac_mode_6_hdr
{
65 struct rdac_mode_10_hdr
{
73 struct rdac_mode_common
{
74 u8 controller_serial
[16];
75 u8 alt_controller_serial
[16];
78 u8 quiescence_timeout
;
82 struct rdac_pg_legacy
{
83 struct rdac_mode_6_hdr hdr
;
86 struct rdac_mode_common common
;
87 #define MODE6_MAX_LUN 32
88 u8 lun_table
[MODE6_MAX_LUN
];
94 struct rdac_pg_expanded
{
95 struct rdac_mode_10_hdr hdr
;
99 struct rdac_mode_common common
;
107 u8 page_code
; /* 0xC9 */
110 u8 page_id
[4]; /* "vace" */
116 #define SUBSYS_ID_LEN 16
117 #define SLOT_ID_LEN 2
118 #define ARRAY_LABEL_LEN 31
122 u8 page_code
; /* 0xC4 */
125 u8 page_id
[4]; /* "subs" */
126 u8 subsys_id
[SUBSYS_ID_LEN
];
128 u8 slot_id
[SLOT_ID_LEN
];
132 #define UNIQUE_ID_LEN 16
135 u8 page_code
; /* 0xC8 */
138 u8 page_id
[4]; /* "edid" */
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];
151 struct rdac_controller
{
152 u8 array_id
[UNIQUE_ID_LEN
];
155 struct list_head node
; /* list of all controllers */
157 struct rdac_pg_legacy legacy
;
158 struct rdac_pg_expanded expanded
;
161 u8 array_name
[ARRAY_LABEL_LEN
];
162 struct Scsi_Host
*host
;
165 struct work_struct ms_work
;
166 struct scsi_device
*ms_sdev
;
167 struct list_head ms_head
;
172 u8 page_code
; /* 0xC2 */
175 u8 page_id
[4]; /* "swr4" */
179 u8 max_lun_supported
;
180 u8 partitions
[239]; /* Total allocation length should be 0xFF */
183 struct rdac_dh_data
{
184 struct rdac_controller
*ctlr
;
185 #define UNINITIALIZED_LUN (1 << 8)
189 #define RDAC_MODE_AVT 1
190 #define RDAC_MODE_IOSHIP 2
193 #define RDAC_STATE_ACTIVE 0
194 #define RDAC_STATE_PASSIVE 1
197 #define RDAC_LUN_UNOWNED 0
198 #define RDAC_LUN_OWNED 1
201 #define RDAC_PREFERRED 0
202 #define RDAC_NON_PREFERRED 1
205 unsigned char sense
[SCSI_SENSE_BUFFERSIZE
];
207 struct c2_inquiry c2
;
208 struct c4_inquiry c4
;
209 struct c8_inquiry c8
;
210 struct c9_inquiry c9
;
214 static const char *mode
[] = {
219 static const char *lun_state
[] =
225 struct rdac_queue_data
{
226 struct list_head entry
;
227 struct rdac_dh_data
*h
;
228 activate_complete callback_fn
;
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
);
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
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");
248 #define RDAC_LOG_FAILOVER 0
249 #define RDAC_LOG_SENSE 2
251 #define RDAC_LOG_BITS 2
253 #define RDAC_LOG_LEVEL(SHIFT) \
254 ((rdac_logging >> (SHIFT)) & ((1 << (RDAC_LOG_BITS)) - 1))
256 #define RDAC_LOG(SHIFT, sdev, f, arg...) \
258 if (unlikely(RDAC_LOG_LEVEL(SHIFT))) \
259 sdev_printk(KERN_INFO, sdev, RDAC_NAME ": " f "\n", ## arg); \
262 static inline struct rdac_dh_data
*get_rdac_data(struct scsi_device
*sdev
)
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
);
269 static struct request
*get_rdac_req(struct scsi_device
*sdev
,
270 void *buffer
, unsigned buflen
, int rw
)
273 struct request_queue
*q
= sdev
->request_queue
;
275 rq
= blk_get_request(q
, rw
, GFP_NOIO
);
278 sdev_printk(KERN_INFO
, sdev
,
279 "get_rdac_req: blk_get_request failed.\n");
283 if (buflen
&& blk_rq_map_kern(q
, rq
, buffer
, buflen
, GFP_NOIO
)) {
285 sdev_printk(KERN_INFO
, sdev
,
286 "get_rdac_req: blk_rq_map_kern failed.\n");
290 rq
->cmd_type
= REQ_TYPE_BLOCK_PC
;
291 rq
->cmd_flags
|= REQ_FAILFAST_DEV
| REQ_FAILFAST_TRANSPORT
|
293 rq
->retries
= RDAC_RETRIES
;
294 rq
->timeout
= RDAC_TIMEOUT
;
299 static struct request
*rdac_failover_get(struct scsi_device
*sdev
,
300 struct rdac_dh_data
*h
, struct list_head
*list
)
303 struct rdac_mode_common
*common
;
305 struct rdac_queue_data
*qdata
;
308 if (h
->ctlr
->use_ms10
) {
309 struct rdac_pg_expanded
*rdac_pg
;
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
;
321 struct rdac_pg_legacy
*rdac_pg
;
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
;
331 common
->rdac_mode
[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS
;
332 common
->quiescence_timeout
= RDAC_QUIESCENCE_TIME
;
333 common
->rdac_options
= RDAC_FORCED_QUIESENCE
;
335 list_for_each_entry(qdata
, list
, entry
) {
336 lun_table
[qdata
->h
->lun
] = 0x81;
339 /* get request for block layer packet command */
340 rq
= get_rdac_req(sdev
, &h
->ctlr
->mode_select
, data_size
, WRITE
);
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;
350 rq
->cmd
[0] = MODE_SELECT
;
351 rq
->cmd
[4] = data_size
;
353 rq
->cmd_len
= COMMAND_SIZE(rq
->cmd
[0]);
355 rq
->sense
= h
->sense
;
356 memset(rq
->sense
, 0, SCSI_SENSE_BUFFERSIZE
);
362 static void release_controller(struct kref
*kref
)
364 struct rdac_controller
*ctlr
;
365 ctlr
= container_of(kref
, struct rdac_controller
, kref
);
367 flush_workqueue(kmpath_rdacd
);
368 spin_lock(&list_lock
);
369 list_del(&ctlr
->node
);
370 spin_unlock(&list_lock
);
374 static struct rdac_controller
*get_controller(int index
, char *array_name
,
375 u8
*array_id
, struct scsi_device
*sdev
)
377 struct rdac_controller
*ctlr
, *tmp
;
379 spin_lock(&list_lock
);
381 list_for_each_entry(tmp
, &ctlr_list
, node
) {
382 if ((memcmp(tmp
->array_id
, array_id
, UNIQUE_ID_LEN
) == 0) &&
383 (tmp
->index
== index
) &&
384 (tmp
->host
== sdev
->host
)) {
385 kref_get(&tmp
->kref
);
386 spin_unlock(&list_lock
);
390 ctlr
= kmalloc(sizeof(*ctlr
), GFP_ATOMIC
);
394 /* initialize fields of controller */
395 memcpy(ctlr
->array_id
, array_id
, UNIQUE_ID_LEN
);
397 ctlr
->host
= sdev
->host
;
398 memcpy(ctlr
->array_name
, array_name
, ARRAY_LABEL_LEN
);
400 kref_init(&ctlr
->kref
);
403 ctlr
->ms_sdev
= NULL
;
404 spin_lock_init(&ctlr
->ms_lock
);
405 INIT_WORK(&ctlr
->ms_work
, send_mode_select
);
406 INIT_LIST_HEAD(&ctlr
->ms_head
);
407 list_add(&ctlr
->node
, &ctlr_list
);
409 spin_unlock(&list_lock
);
413 static int submit_inquiry(struct scsi_device
*sdev
, int page_code
,
414 unsigned int len
, struct rdac_dh_data
*h
)
417 struct request_queue
*q
= sdev
->request_queue
;
418 int err
= SCSI_DH_RES_TEMP_UNAVAIL
;
420 rq
= get_rdac_req(sdev
, &h
->inq
, len
, READ
);
424 /* Prepare the command. */
425 rq
->cmd
[0] = INQUIRY
;
427 rq
->cmd
[2] = page_code
;
429 rq
->cmd_len
= COMMAND_SIZE(INQUIRY
);
431 rq
->sense
= h
->sense
;
432 memset(rq
->sense
, 0, SCSI_SENSE_BUFFERSIZE
);
435 err
= blk_execute_rq(q
, NULL
, rq
, 1);
444 static int get_lun_info(struct scsi_device
*sdev
, struct rdac_dh_data
*h
,
445 char *array_name
, u8
*array_id
)
448 struct c8_inquiry
*inqp
;
450 err
= submit_inquiry(sdev
, 0xC8, sizeof(struct c8_inquiry
), h
);
451 if (err
== SCSI_DH_OK
) {
453 if (inqp
->page_code
!= 0xc8)
454 return SCSI_DH_NOSYS
;
455 if (inqp
->page_id
[0] != 'e' || inqp
->page_id
[1] != 'd' ||
456 inqp
->page_id
[2] != 'i' || inqp
->page_id
[3] != 'd')
457 return SCSI_DH_NOSYS
;
458 h
->lun
= inqp
->lun
[7]; /* Uses only the last byte */
460 for(i
=0; i
<ARRAY_LABEL_LEN
-1; ++i
)
461 *(array_name
+i
) = inqp
->array_user_label
[(2*i
)+1];
463 *(array_name
+ARRAY_LABEL_LEN
-1) = '\0';
464 memset(array_id
, 0, UNIQUE_ID_LEN
);
465 memcpy(array_id
, inqp
->array_unique_id
, inqp
->array_uniq_id_len
);
470 static int check_ownership(struct scsi_device
*sdev
, struct rdac_dh_data
*h
)
473 struct c9_inquiry
*inqp
;
475 h
->state
= RDAC_STATE_ACTIVE
;
476 err
= submit_inquiry(sdev
, 0xC9, sizeof(struct c9_inquiry
), h
);
477 if (err
== SCSI_DH_OK
) {
479 /* detect the operating mode */
480 if ((inqp
->avte_cvp
>> 5) & 0x1)
481 h
->mode
= RDAC_MODE_IOSHIP
; /* LUN in IOSHIP mode */
482 else if (inqp
->avte_cvp
>> 7)
483 h
->mode
= RDAC_MODE_AVT
; /* LUN in AVT mode */
485 h
->mode
= RDAC_MODE
; /* LUN in RDAC mode */
487 /* Update ownership */
488 if (inqp
->avte_cvp
& 0x1)
489 h
->lun_state
= RDAC_LUN_OWNED
;
491 h
->lun_state
= RDAC_LUN_UNOWNED
;
492 if (h
->mode
== RDAC_MODE
)
493 h
->state
= RDAC_STATE_PASSIVE
;
496 /* Update path prio*/
497 if (inqp
->path_prio
& 0x1)
498 h
->preferred
= RDAC_PREFERRED
;
500 h
->preferred
= RDAC_NON_PREFERRED
;
506 static int initialize_controller(struct scsi_device
*sdev
,
507 struct rdac_dh_data
*h
, char *array_name
, u8
*array_id
)
510 struct c4_inquiry
*inqp
;
512 err
= submit_inquiry(sdev
, 0xC4, sizeof(struct c4_inquiry
), h
);
513 if (err
== SCSI_DH_OK
) {
515 /* get the controller index */
516 if (inqp
->slot_id
[1] == 0x31)
520 h
->ctlr
= get_controller(index
, array_name
, array_id
, sdev
);
522 err
= SCSI_DH_RES_TEMP_UNAVAIL
;
527 static int set_mode_select(struct scsi_device
*sdev
, struct rdac_dh_data
*h
)
530 struct c2_inquiry
*inqp
;
532 err
= submit_inquiry(sdev
, 0xC2, sizeof(struct c2_inquiry
), h
);
533 if (err
== SCSI_DH_OK
) {
536 * If more than MODE6_MAX_LUN luns are supported, use
539 if (inqp
->max_lun_supported
>= MODE6_MAX_LUN
)
540 h
->ctlr
->use_ms10
= 1;
542 h
->ctlr
->use_ms10
= 0;
547 static int mode_select_handle_sense(struct scsi_device
*sdev
,
548 unsigned char *sensebuf
)
550 struct scsi_sense_hdr sense_hdr
;
551 int err
= SCSI_DH_IO
, ret
;
552 struct rdac_dh_data
*h
= get_rdac_data(sdev
);
554 ret
= scsi_normalize_sense(sensebuf
, SCSI_SENSE_BUFFERSIZE
, &sense_hdr
);
558 switch (sense_hdr
.sense_key
) {
560 case ABORTED_COMMAND
:
565 if (sense_hdr
.asc
== 0x04 && sense_hdr
.ascq
== 0x01)
566 /* LUN Not Ready and is in the Process of Becoming
571 case ILLEGAL_REQUEST
:
572 if (sense_hdr
.asc
== 0x91 && sense_hdr
.ascq
== 0x36)
574 * Command Lock contention
582 RDAC_LOG(RDAC_LOG_FAILOVER
, sdev
, "array %s, ctlr %d, "
583 "MODE_SELECT returned with sense %02x/%02x/%02x",
584 (char *) h
->ctlr
->array_name
, h
->ctlr
->index
,
585 sense_hdr
.sense_key
, sense_hdr
.asc
, sense_hdr
.ascq
);
591 static void send_mode_select(struct work_struct
*work
)
593 struct rdac_controller
*ctlr
=
594 container_of(work
, struct rdac_controller
, ms_work
);
596 struct scsi_device
*sdev
= ctlr
->ms_sdev
;
597 struct rdac_dh_data
*h
= get_rdac_data(sdev
);
598 struct request_queue
*q
= sdev
->request_queue
;
599 int err
, retry_cnt
= RDAC_RETRY_COUNT
;
600 struct rdac_queue_data
*tmp
, *qdata
;
603 spin_lock(&ctlr
->ms_lock
);
604 list_splice_init(&ctlr
->ms_head
, &list
);
606 ctlr
->ms_sdev
= NULL
;
607 spin_unlock(&ctlr
->ms_lock
);
610 err
= SCSI_DH_RES_TEMP_UNAVAIL
;
611 rq
= rdac_failover_get(sdev
, h
, &list
);
615 RDAC_LOG(RDAC_LOG_FAILOVER
, sdev
, "array %s, ctlr %d, "
616 "%s MODE_SELECT command",
617 (char *) h
->ctlr
->array_name
, h
->ctlr
->index
,
618 (retry_cnt
== RDAC_RETRY_COUNT
) ? "queueing" : "retrying");
620 err
= blk_execute_rq(q
, NULL
, rq
, 1);
622 if (err
!= SCSI_DH_OK
) {
623 err
= mode_select_handle_sense(sdev
, h
->sense
);
624 if (err
== SCSI_DH_RETRY
&& retry_cnt
--)
627 if (err
== SCSI_DH_OK
) {
628 h
->state
= RDAC_STATE_ACTIVE
;
629 RDAC_LOG(RDAC_LOG_FAILOVER
, sdev
, "array %s, ctlr %d, "
630 "MODE_SELECT completed",
631 (char *) h
->ctlr
->array_name
, h
->ctlr
->index
);
635 list_for_each_entry_safe(qdata
, tmp
, &list
, entry
) {
636 list_del(&qdata
->entry
);
637 if (err
== SCSI_DH_OK
)
638 qdata
->h
->state
= RDAC_STATE_ACTIVE
;
639 if (qdata
->callback_fn
)
640 qdata
->callback_fn(qdata
->callback_data
, err
);
646 static int queue_mode_select(struct scsi_device
*sdev
,
647 activate_complete fn
, void *data
)
649 struct rdac_queue_data
*qdata
;
650 struct rdac_controller
*ctlr
;
652 qdata
= kzalloc(sizeof(*qdata
), GFP_KERNEL
);
654 return SCSI_DH_RETRY
;
656 qdata
->h
= get_rdac_data(sdev
);
657 qdata
->callback_fn
= fn
;
658 qdata
->callback_data
= data
;
660 ctlr
= qdata
->h
->ctlr
;
661 spin_lock(&ctlr
->ms_lock
);
662 list_add_tail(&qdata
->entry
, &ctlr
->ms_head
);
663 if (!ctlr
->ms_queued
) {
665 ctlr
->ms_sdev
= sdev
;
666 queue_work(kmpath_rdacd
, &ctlr
->ms_work
);
668 spin_unlock(&ctlr
->ms_lock
);
672 static int rdac_activate(struct scsi_device
*sdev
,
673 activate_complete fn
, void *data
)
675 struct rdac_dh_data
*h
= get_rdac_data(sdev
);
676 int err
= SCSI_DH_OK
;
679 err
= check_ownership(sdev
, h
);
680 if (err
!= SCSI_DH_OK
)
685 if (h
->lun_state
== RDAC_LUN_UNOWNED
)
688 case RDAC_MODE_IOSHIP
:
689 if ((h
->lun_state
== RDAC_LUN_UNOWNED
) &&
690 (h
->preferred
== RDAC_PREFERRED
))
698 err
= queue_mode_select(sdev
, fn
, data
);
699 if (err
== SCSI_DH_OK
)
708 static int rdac_prep_fn(struct scsi_device
*sdev
, struct request
*req
)
710 struct rdac_dh_data
*h
= get_rdac_data(sdev
);
711 int ret
= BLKPREP_OK
;
713 if (h
->state
!= RDAC_STATE_ACTIVE
) {
715 req
->cmd_flags
|= REQ_QUIET
;
721 static int rdac_check_sense(struct scsi_device
*sdev
,
722 struct scsi_sense_hdr
*sense_hdr
)
724 struct rdac_dh_data
*h
= get_rdac_data(sdev
);
726 RDAC_LOG(RDAC_LOG_SENSE
, sdev
, "array %s, ctlr %d, "
727 "I/O returned with sense %02x/%02x/%02x",
728 (char *) h
->ctlr
->array_name
, h
->ctlr
->index
,
729 sense_hdr
->sense_key
, sense_hdr
->asc
, sense_hdr
->ascq
);
731 switch (sense_hdr
->sense_key
) {
733 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0x01)
734 /* LUN Not Ready - Logical Unit Not Ready and is in
735 * the process of becoming ready
738 return ADD_TO_MLQUEUE
;
739 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0x81)
740 /* LUN Not Ready - Storage firmware incompatible
741 * Manual code synchonisation required.
743 * Nothing we can do here. Try to bypass the path.
746 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0xA1)
747 /* LUN Not Ready - Quiescense in progress
749 * Just retry and wait.
751 return ADD_TO_MLQUEUE
;
752 if (sense_hdr
->asc
== 0xA1 && sense_hdr
->ascq
== 0x02)
753 /* LUN Not Ready - Quiescense in progress
754 * or has been achieved
757 return ADD_TO_MLQUEUE
;
759 case ILLEGAL_REQUEST
:
760 if (sense_hdr
->asc
== 0x94 && sense_hdr
->ascq
== 0x01) {
761 /* Invalid Request - Current Logical Unit Ownership.
762 * Controller is not the current owner of the LUN,
763 * Fail the path, so that the other path be used.
765 h
->state
= RDAC_STATE_PASSIVE
;
770 if (sense_hdr
->asc
== 0x29 && sense_hdr
->ascq
== 0x00)
772 * Power On, Reset, or Bus Device Reset, just retry.
774 return ADD_TO_MLQUEUE
;
775 if (sense_hdr
->asc
== 0x8b && sense_hdr
->ascq
== 0x02)
777 * Quiescence in progress , just retry.
779 return ADD_TO_MLQUEUE
;
782 /* success just means we do not care what scsi-ml does */
783 return SCSI_RETURN_NOT_HANDLED
;
786 static const struct scsi_dh_devlist rdac_dev_list
[] = {
800 {"STK", "OPENstorage D280"},
802 {"SUN", "LCSM100_I"},
803 {"SUN", "LCSM100_S"},
804 {"SUN", "LCSM100_E"},
805 {"SUN", "LCSM100_F"},
812 {"LSI", "INF-01-00"},
813 {"ENGENIO", "INF-01-00"},
814 {"STK", "FLEXLINE 380"},
815 {"SUN", "CSM100_R_FC"},
816 {"SUN", "STK6580_6780"},
821 static int rdac_bus_attach(struct scsi_device
*sdev
);
822 static void rdac_bus_detach(struct scsi_device
*sdev
);
824 static struct scsi_device_handler rdac_dh
= {
826 .module
= THIS_MODULE
,
827 .devlist
= rdac_dev_list
,
828 .prep_fn
= rdac_prep_fn
,
829 .check_sense
= rdac_check_sense
,
830 .attach
= rdac_bus_attach
,
831 .detach
= rdac_bus_detach
,
832 .activate
= rdac_activate
,
835 static int rdac_bus_attach(struct scsi_device
*sdev
)
837 struct scsi_dh_data
*scsi_dh_data
;
838 struct rdac_dh_data
*h
;
841 char array_name
[ARRAY_LABEL_LEN
];
842 char array_id
[UNIQUE_ID_LEN
];
844 scsi_dh_data
= kzalloc(sizeof(*scsi_dh_data
)
845 + sizeof(*h
) , GFP_KERNEL
);
847 sdev_printk(KERN_ERR
, sdev
, "%s: Attach failed\n",
852 scsi_dh_data
->scsi_dh
= &rdac_dh
;
853 h
= (struct rdac_dh_data
*) scsi_dh_data
->buf
;
854 h
->lun
= UNINITIALIZED_LUN
;
855 h
->state
= RDAC_STATE_ACTIVE
;
857 err
= get_lun_info(sdev
, h
, array_name
, array_id
);
858 if (err
!= SCSI_DH_OK
)
861 err
= initialize_controller(sdev
, h
, array_name
, array_id
);
862 if (err
!= SCSI_DH_OK
)
865 err
= check_ownership(sdev
, h
);
866 if (err
!= SCSI_DH_OK
)
869 err
= set_mode_select(sdev
, h
);
870 if (err
!= SCSI_DH_OK
)
873 if (!try_module_get(THIS_MODULE
))
876 spin_lock_irqsave(sdev
->request_queue
->queue_lock
, flags
);
877 sdev
->scsi_dh_data
= scsi_dh_data
;
878 spin_unlock_irqrestore(sdev
->request_queue
->queue_lock
, flags
);
880 sdev_printk(KERN_NOTICE
, sdev
,
881 "%s: LUN %d (%s) (%s)\n",
882 RDAC_NAME
, h
->lun
, mode
[(int)h
->mode
],
883 lun_state
[(int)h
->lun_state
]);
888 kref_put(&h
->ctlr
->kref
, release_controller
);
892 sdev_printk(KERN_ERR
, sdev
, "%s: not attached\n",
897 static void rdac_bus_detach( struct scsi_device
*sdev
)
899 struct scsi_dh_data
*scsi_dh_data
;
900 struct rdac_dh_data
*h
;
903 spin_lock_irqsave(sdev
->request_queue
->queue_lock
, flags
);
904 scsi_dh_data
= sdev
->scsi_dh_data
;
905 sdev
->scsi_dh_data
= NULL
;
906 spin_unlock_irqrestore(sdev
->request_queue
->queue_lock
, flags
);
908 h
= (struct rdac_dh_data
*) scsi_dh_data
->buf
;
910 kref_put(&h
->ctlr
->kref
, release_controller
);
912 module_put(THIS_MODULE
);
913 sdev_printk(KERN_NOTICE
, sdev
, "%s: Detached\n", RDAC_NAME
);
918 static int __init
rdac_init(void)
922 r
= scsi_register_device_handler(&rdac_dh
);
924 printk(KERN_ERR
"Failed to register scsi device handler.");
929 * Create workqueue to handle mode selects for rdac
931 kmpath_rdacd
= create_singlethread_workqueue("kmpath_rdacd");
933 scsi_unregister_device_handler(&rdac_dh
);
934 printk(KERN_ERR
"kmpath_rdacd creation failed.\n");
940 static void __exit
rdac_exit(void)
942 destroy_workqueue(kmpath_rdacd
);
943 scsi_unregister_device_handler(&rdac_dh
);
946 module_init(rdac_init
);
947 module_exit(rdac_exit
);
949 MODULE_DESCRIPTION("Multipath LSI/Engenio RDAC driver");
950 MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
951 MODULE_VERSION("01.00.0000.0000");
952 MODULE_LICENSE("GPL");