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>
26 #define RDAC_NAME "rdac"
31 * These struct definitions and the forming of the
32 * mode page were taken from the LSI RDAC 2.4 GPL'd
33 * driver, and then converted to Linux conventions.
35 #define RDAC_QUIESCENCE_TIME 20;
39 #define RDAC_PAGE_CODE_REDUNDANT_CONTROLLER 0x2c
42 * Controller modes definitions
44 #define RDAC_MODE_TRANSFER_SPECIFIED_LUNS 0x02
49 #define RDAC_FORCED_QUIESENCE 0x02
51 #define RDAC_TIMEOUT (60 * HZ)
52 #define RDAC_RETRIES 3
54 struct rdac_mode_6_hdr
{
61 struct rdac_mode_10_hdr
{
69 struct rdac_mode_common
{
70 u8 controller_serial
[16];
71 u8 alt_controller_serial
[16];
74 u8 quiescence_timeout
;
78 struct rdac_pg_legacy
{
79 struct rdac_mode_6_hdr hdr
;
82 struct rdac_mode_common common
;
83 #define MODE6_MAX_LUN 32
84 u8 lun_table
[MODE6_MAX_LUN
];
90 struct rdac_pg_expanded
{
91 struct rdac_mode_10_hdr hdr
;
95 struct rdac_mode_common common
;
103 u8 page_code
; /* 0xC9 */
106 u8 page_id
[4]; /* "vace" */
112 #define SUBSYS_ID_LEN 16
113 #define SLOT_ID_LEN 2
117 u8 page_code
; /* 0xC4 */
120 u8 page_id
[4]; /* "subs" */
121 u8 subsys_id
[SUBSYS_ID_LEN
];
123 u8 slot_id
[SLOT_ID_LEN
];
127 struct rdac_controller
{
128 u8 subsys_id
[SUBSYS_ID_LEN
];
129 u8 slot_id
[SLOT_ID_LEN
];
132 struct list_head node
; /* list of all controllers */
134 struct rdac_pg_legacy legacy
;
135 struct rdac_pg_expanded expanded
;
140 u8 page_code
; /* 0xC8 */
143 u8 page_id
[4]; /* "edid" */
147 u8 vol_user_label_len
;
148 u8 vol_user_label
[60];
149 u8 array_uniq_id_len
;
150 u8 array_unique_id
[16];
151 u8 array_user_label_len
;
152 u8 array_user_label
[60];
158 u8 page_code
; /* 0xC2 */
161 u8 page_id
[4]; /* "swr4" */
165 u8 max_lun_supported
;
166 u8 partitions
[239]; /* Total allocation length should be 0xFF */
169 struct rdac_dh_data
{
170 struct rdac_controller
*ctlr
;
171 #define UNINITIALIZED_LUN (1 << 8)
173 #define RDAC_STATE_ACTIVE 0
174 #define RDAC_STATE_PASSIVE 1
177 #define RDAC_LUN_UNOWNED 0
178 #define RDAC_LUN_OWNED 1
179 #define RDAC_LUN_AVT 2
181 unsigned char sense
[SCSI_SENSE_BUFFERSIZE
];
183 struct c2_inquiry c2
;
184 struct c4_inquiry c4
;
185 struct c8_inquiry c8
;
186 struct c9_inquiry c9
;
190 static const char *lun_state
[] =
197 static LIST_HEAD(ctlr_list
);
198 static DEFINE_SPINLOCK(list_lock
);
200 static inline struct rdac_dh_data
*get_rdac_data(struct scsi_device
*sdev
)
202 struct scsi_dh_data
*scsi_dh_data
= sdev
->scsi_dh_data
;
203 BUG_ON(scsi_dh_data
== NULL
);
204 return ((struct rdac_dh_data
*) scsi_dh_data
->buf
);
207 static struct request
*get_rdac_req(struct scsi_device
*sdev
,
208 void *buffer
, unsigned buflen
, int rw
)
211 struct request_queue
*q
= sdev
->request_queue
;
213 rq
= blk_get_request(q
, rw
, GFP_NOIO
);
216 sdev_printk(KERN_INFO
, sdev
,
217 "get_rdac_req: blk_get_request failed.\n");
221 if (buflen
&& blk_rq_map_kern(q
, rq
, buffer
, buflen
, GFP_NOIO
)) {
223 sdev_printk(KERN_INFO
, sdev
,
224 "get_rdac_req: blk_rq_map_kern failed.\n");
228 memset(rq
->cmd
, 0, BLK_MAX_CDB
);
230 rq
->cmd_type
= REQ_TYPE_BLOCK_PC
;
231 rq
->cmd_flags
|= REQ_FAILFAST
| REQ_NOMERGE
;
232 rq
->retries
= RDAC_RETRIES
;
233 rq
->timeout
= RDAC_TIMEOUT
;
238 static struct request
*rdac_failover_get(struct scsi_device
*sdev
,
239 struct rdac_dh_data
*h
)
242 struct rdac_mode_common
*common
;
245 if (h
->ctlr
->use_ms10
) {
246 struct rdac_pg_expanded
*rdac_pg
;
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;
258 struct rdac_pg_legacy
*rdac_pg
;
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;
268 common
->rdac_mode
[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS
;
269 common
->quiescence_timeout
= RDAC_QUIESCENCE_TIME
;
270 common
->rdac_options
= RDAC_FORCED_QUIESENCE
;
272 /* get request for block layer packet command */
273 rq
= get_rdac_req(sdev
, &h
->ctlr
->mode_select
, data_size
, WRITE
);
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;
283 rq
->cmd
[0] = MODE_SELECT
;
284 rq
->cmd
[4] = data_size
;
286 rq
->cmd_len
= COMMAND_SIZE(rq
->cmd
[0]);
288 rq
->sense
= h
->sense
;
289 memset(rq
->sense
, 0, SCSI_SENSE_BUFFERSIZE
);
295 static void release_controller(struct kref
*kref
)
297 struct rdac_controller
*ctlr
;
298 ctlr
= container_of(kref
, struct rdac_controller
, kref
);
300 spin_lock(&list_lock
);
301 list_del(&ctlr
->node
);
302 spin_unlock(&list_lock
);
306 static struct rdac_controller
*get_controller(u8
*subsys_id
, u8
*slot_id
)
308 struct rdac_controller
*ctlr
, *tmp
;
310 spin_lock(&list_lock
);
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
);
320 ctlr
= kmalloc(sizeof(*ctlr
), GFP_ATOMIC
);
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
);
329 list_add(&ctlr
->node
, &ctlr_list
);
331 spin_unlock(&list_lock
);
335 static int submit_inquiry(struct scsi_device
*sdev
, int page_code
,
336 unsigned int len
, struct rdac_dh_data
*h
)
339 struct request_queue
*q
= sdev
->request_queue
;
340 int err
= SCSI_DH_RES_TEMP_UNAVAIL
;
342 rq
= get_rdac_req(sdev
, &h
->inq
, len
, READ
);
346 /* Prepare the command. */
347 rq
->cmd
[0] = INQUIRY
;
349 rq
->cmd
[2] = page_code
;
351 rq
->cmd_len
= COMMAND_SIZE(INQUIRY
);
353 rq
->sense
= h
->sense
;
354 memset(rq
->sense
, 0, SCSI_SENSE_BUFFERSIZE
);
357 err
= blk_execute_rq(q
, NULL
, rq
, 1);
366 static int get_lun(struct scsi_device
*sdev
, struct rdac_dh_data
*h
)
369 struct c8_inquiry
*inqp
;
371 err
= submit_inquiry(sdev
, 0xC8, sizeof(struct c8_inquiry
), h
);
372 if (err
== SCSI_DH_OK
) {
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
;
379 h
->lun
= scsilun_to_int((struct scsi_lun
*)inqp
->lun
);
384 static int check_ownership(struct scsi_device
*sdev
, struct rdac_dh_data
*h
)
387 struct c9_inquiry
*inqp
;
389 err
= submit_inquiry(sdev
, 0xC9, sizeof(struct c9_inquiry
), h
);
390 if (err
== SCSI_DH_OK
) {
392 if ((inqp
->avte_cvp
>> 7) == 0x1) {
393 /* LUN in AVT mode */
394 sdev_printk(KERN_NOTICE
, sdev
,
395 "%s: AVT mode detected\n",
397 h
->lun_state
= RDAC_LUN_AVT
;
398 } else if ((inqp
->avte_cvp
& 0x1) != 0) {
399 /* LUN was owned by the controller */
400 h
->lun_state
= RDAC_LUN_OWNED
;
407 static int initialize_controller(struct scsi_device
*sdev
,
408 struct rdac_dh_data
*h
)
411 struct c4_inquiry
*inqp
;
413 err
= submit_inquiry(sdev
, 0xC4, sizeof(struct c4_inquiry
), h
);
414 if (err
== SCSI_DH_OK
) {
416 h
->ctlr
= get_controller(inqp
->subsys_id
, inqp
->slot_id
);
418 err
= SCSI_DH_RES_TEMP_UNAVAIL
;
423 static int set_mode_select(struct scsi_device
*sdev
, struct rdac_dh_data
*h
)
426 struct c2_inquiry
*inqp
;
428 err
= submit_inquiry(sdev
, 0xC2, sizeof(struct c2_inquiry
), h
);
429 if (err
== SCSI_DH_OK
) {
432 * If more than MODE6_MAX_LUN luns are supported, use
435 if (inqp
->max_lun_supported
>= MODE6_MAX_LUN
)
436 h
->ctlr
->use_ms10
= 1;
438 h
->ctlr
->use_ms10
= 0;
443 static int mode_select_handle_sense(struct scsi_device
*sdev
,
444 unsigned char *sensebuf
)
446 struct scsi_sense_hdr sense_hdr
;
447 int sense
, err
= SCSI_DH_IO
, ret
;
449 ret
= scsi_normalize_sense(sensebuf
, SCSI_SENSE_BUFFERSIZE
, &sense_hdr
);
454 sense
= (sense_hdr
.sense_key
<< 16) | (sense_hdr
.asc
<< 8) |
456 /* If it is retryable failure, submit the c9 inquiry again */
457 if (sense
== 0x59136 || sense
== 0x68b02 || sense
== 0xb8b02 ||
459 /* 0x59136 - Command lock contention
460 * 0x[6b]8b02 - Quiesense in progress or achieved
461 * 0x62900 - Power On, Reset, or Bus Device Reset
467 sdev_printk(KERN_INFO
, sdev
,
468 "MODE_SELECT failed with sense 0x%x.\n", sense
);
473 static int send_mode_select(struct scsi_device
*sdev
, struct rdac_dh_data
*h
)
476 struct request_queue
*q
= sdev
->request_queue
;
477 int err
= SCSI_DH_RES_TEMP_UNAVAIL
;
479 rq
= rdac_failover_get(sdev
, h
);
483 sdev_printk(KERN_INFO
, sdev
, "queueing MODE_SELECT command.\n");
485 err
= blk_execute_rq(q
, NULL
, rq
, 1);
486 if (err
!= SCSI_DH_OK
)
487 err
= mode_select_handle_sense(sdev
, h
->sense
);
488 if (err
== SCSI_DH_OK
)
489 h
->state
= RDAC_STATE_ACTIVE
;
496 static int rdac_activate(struct scsi_device
*sdev
)
498 struct rdac_dh_data
*h
= get_rdac_data(sdev
);
499 int err
= SCSI_DH_OK
;
501 err
= check_ownership(sdev
, h
);
502 if (err
!= SCSI_DH_OK
)
506 err
= initialize_controller(sdev
, h
);
507 if (err
!= SCSI_DH_OK
)
511 if (h
->ctlr
->use_ms10
== -1) {
512 err
= set_mode_select(sdev
, h
);
513 if (err
!= SCSI_DH_OK
)
516 if (h
->lun_state
== RDAC_LUN_UNOWNED
)
517 err
= send_mode_select(sdev
, h
);
522 static int rdac_prep_fn(struct scsi_device
*sdev
, struct request
*req
)
524 struct rdac_dh_data
*h
= get_rdac_data(sdev
);
525 int ret
= BLKPREP_OK
;
527 if (h
->state
!= RDAC_STATE_ACTIVE
) {
529 req
->cmd_flags
|= REQ_QUIET
;
535 static int rdac_check_sense(struct scsi_device
*sdev
,
536 struct scsi_sense_hdr
*sense_hdr
)
538 struct rdac_dh_data
*h
= get_rdac_data(sdev
);
539 switch (sense_hdr
->sense_key
) {
541 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0x81)
542 /* LUN Not Ready - Storage firmware incompatible
543 * Manual code synchonisation required.
545 * Nothing we can do here. Try to bypass the path.
548 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0xA1)
549 /* LUN Not Ready - Quiescense in progress
551 * Just retry and wait.
555 case ILLEGAL_REQUEST
:
556 if (sense_hdr
->asc
== 0x94 && sense_hdr
->ascq
== 0x01) {
557 /* Invalid Request - Current Logical Unit Ownership.
558 * Controller is not the current owner of the LUN,
559 * Fail the path, so that the other path be used.
561 h
->state
= RDAC_STATE_PASSIVE
;
566 if (sense_hdr
->asc
== 0x29 && sense_hdr
->ascq
== 0x00)
568 * Power On, Reset, or Bus Device Reset, just retry.
573 /* success just means we do not care what scsi-ml does */
574 return SCSI_RETURN_NOT_HANDLED
;
577 static const struct scsi_dh_devlist rdac_dev_list
[] = {
589 {"STK", "OPENstorage D280"},
591 {"SUN", "LCSM100_F"},
595 static int rdac_bus_attach(struct scsi_device
*sdev
);
596 static void rdac_bus_detach(struct scsi_device
*sdev
);
598 static struct scsi_device_handler rdac_dh
= {
600 .module
= THIS_MODULE
,
601 .devlist
= rdac_dev_list
,
602 .prep_fn
= rdac_prep_fn
,
603 .check_sense
= rdac_check_sense
,
604 .attach
= rdac_bus_attach
,
605 .detach
= rdac_bus_detach
,
606 .activate
= rdac_activate
,
609 static int rdac_bus_attach(struct scsi_device
*sdev
)
611 struct scsi_dh_data
*scsi_dh_data
;
612 struct rdac_dh_data
*h
;
616 scsi_dh_data
= kzalloc(sizeof(struct scsi_device_handler
*)
617 + sizeof(*h
) , GFP_KERNEL
);
619 sdev_printk(KERN_ERR
, sdev
, "%s: Attach failed\n",
624 scsi_dh_data
->scsi_dh
= &rdac_dh
;
625 h
= (struct rdac_dh_data
*) scsi_dh_data
->buf
;
626 h
->lun
= UNINITIALIZED_LUN
;
627 h
->state
= RDAC_STATE_ACTIVE
;
629 err
= get_lun(sdev
, h
);
630 if (err
!= SCSI_DH_OK
)
633 err
= check_ownership(sdev
, h
);
634 if (err
!= SCSI_DH_OK
)
637 if (!try_module_get(THIS_MODULE
))
640 spin_lock_irqsave(sdev
->request_queue
->queue_lock
, flags
);
641 sdev
->scsi_dh_data
= scsi_dh_data
;
642 spin_unlock_irqrestore(sdev
->request_queue
->queue_lock
, flags
);
644 sdev_printk(KERN_NOTICE
, sdev
,
646 RDAC_NAME
, h
->lun
, lun_state
[(int)h
->lun_state
]);
652 sdev_printk(KERN_ERR
, sdev
, "%s: not attached\n",
657 static void rdac_bus_detach( struct scsi_device
*sdev
)
659 struct scsi_dh_data
*scsi_dh_data
;
660 struct rdac_dh_data
*h
;
663 spin_lock_irqsave(sdev
->request_queue
->queue_lock
, flags
);
664 scsi_dh_data
= sdev
->scsi_dh_data
;
665 sdev
->scsi_dh_data
= NULL
;
666 spin_unlock_irqrestore(sdev
->request_queue
->queue_lock
, flags
);
668 h
= (struct rdac_dh_data
*) scsi_dh_data
->buf
;
670 kref_put(&h
->ctlr
->kref
, release_controller
);
672 module_put(THIS_MODULE
);
673 sdev_printk(KERN_NOTICE
, sdev
, "%s: Detached\n", RDAC_NAME
);
678 static int __init
rdac_init(void)
682 r
= scsi_register_device_handler(&rdac_dh
);
684 printk(KERN_ERR
"Failed to register scsi device handler.");
688 static void __exit
rdac_exit(void)
690 scsi_unregister_device_handler(&rdac_dh
);
693 module_init(rdac_init
);
694 module_exit(rdac_exit
);
696 MODULE_DESCRIPTION("Multipath LSI/Engenio RDAC driver");
697 MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
698 MODULE_LICENSE("GPL");