]> err.no Git - linux-2.6/blob - drivers/scsi/device_handler/scsi_dh_rdac.c
Merge branch 'for-linus' of git://neil.brown.name/md
[linux-2.6] / drivers / scsi / device_handler / scsi_dh_rdac.c
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"
27
28 /*
29  * LSI mode page stuff
30  *
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.
34  */
35 #define RDAC_QUIESCENCE_TIME 20;
36 /*
37  * Page Codes
38  */
39 #define RDAC_PAGE_CODE_REDUNDANT_CONTROLLER 0x2c
40
41 /*
42  * Controller modes definitions
43  */
44 #define RDAC_MODE_TRANSFER_SPECIFIED_LUNS       0x02
45
46 /*
47  * RDAC Options field
48  */
49 #define RDAC_FORCED_QUIESENCE 0x02
50
51 #define RDAC_TIMEOUT    (60 * HZ)
52 #define RDAC_RETRIES    3
53
54 struct rdac_mode_6_hdr {
55         u8      data_len;
56         u8      medium_type;
57         u8      device_params;
58         u8      block_desc_len;
59 };
60
61 struct rdac_mode_10_hdr {
62         u16     data_len;
63         u8      medium_type;
64         u8      device_params;
65         u16     reserved;
66         u16     block_desc_len;
67 };
68
69 struct rdac_mode_common {
70         u8      controller_serial[16];
71         u8      alt_controller_serial[16];
72         u8      rdac_mode[2];
73         u8      alt_rdac_mode[2];
74         u8      quiescence_timeout;
75         u8      rdac_options;
76 };
77
78 struct rdac_pg_legacy {
79         struct rdac_mode_6_hdr hdr;
80         u8      page_code;
81         u8      page_len;
82         struct rdac_mode_common common;
83 #define MODE6_MAX_LUN   32
84         u8      lun_table[MODE6_MAX_LUN];
85         u8      reserved2[32];
86         u8      reserved3;
87         u8      reserved4;
88 };
89
90 struct rdac_pg_expanded {
91         struct rdac_mode_10_hdr hdr;
92         u8      page_code;
93         u8      subpage_code;
94         u8      page_len[2];
95         struct rdac_mode_common common;
96         u8      lun_table[256];
97         u8      reserved3;
98         u8      reserved4;
99 };
100
101 struct c9_inquiry {
102         u8      peripheral_info;
103         u8      page_code;      /* 0xC9 */
104         u8      reserved1;
105         u8      page_len;
106         u8      page_id[4];     /* "vace" */
107         u8      avte_cvp;
108         u8      path_prio;
109         u8      reserved2[38];
110 };
111
112 #define SUBSYS_ID_LEN   16
113 #define SLOT_ID_LEN     2
114
115 struct c4_inquiry {
116         u8      peripheral_info;
117         u8      page_code;      /* 0xC4 */
118         u8      reserved1;
119         u8      page_len;
120         u8      page_id[4];     /* "subs" */
121         u8      subsys_id[SUBSYS_ID_LEN];
122         u8      revision[4];
123         u8      slot_id[SLOT_ID_LEN];
124         u8      reserved[2];
125 };
126
127 struct rdac_controller {
128         u8                      subsys_id[SUBSYS_ID_LEN];
129         u8                      slot_id[SLOT_ID_LEN];
130         int                     use_ms10;
131         struct kref             kref;
132         struct list_head        node; /* list of all controllers */
133         union                   {
134                 struct rdac_pg_legacy legacy;
135                 struct rdac_pg_expanded expanded;
136         } mode_select;
137 };
138 struct c8_inquiry {
139         u8      peripheral_info;
140         u8      page_code; /* 0xC8 */
141         u8      reserved1;
142         u8      page_len;
143         u8      page_id[4]; /* "edid" */
144         u8      reserved2[3];
145         u8      vol_uniq_id_len;
146         u8      vol_uniq_id[16];
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];
153         u8      lun[8];
154 };
155
156 struct c2_inquiry {
157         u8      peripheral_info;
158         u8      page_code;      /* 0xC2 */
159         u8      reserved1;
160         u8      page_len;
161         u8      page_id[4];     /* "swr4" */
162         u8      sw_version[3];
163         u8      sw_date[3];
164         u8      features_enabled;
165         u8      max_lun_supported;
166         u8      partitions[239]; /* Total allocation length should be 0xFF */
167 };
168
169 struct rdac_dh_data {
170         struct rdac_controller  *ctlr;
171 #define UNINITIALIZED_LUN       (1 << 8)
172         unsigned                lun;
173 #define RDAC_STATE_ACTIVE       0
174 #define RDAC_STATE_PASSIVE      1
175         unsigned char           state;
176
177 #define RDAC_LUN_UNOWNED        0
178 #define RDAC_LUN_OWNED          1
179 #define RDAC_LUN_AVT            2
180         char                    lun_state;
181         unsigned char           sense[SCSI_SENSE_BUFFERSIZE];
182         union                   {
183                 struct c2_inquiry c2;
184                 struct c4_inquiry c4;
185                 struct c8_inquiry c8;
186                 struct c9_inquiry c9;
187         } inq;
188 };
189
190 static const char *lun_state[] =
191 {
192         "unowned",
193         "owned",
194         "owned (AVT mode)",
195 };
196
197 static LIST_HEAD(ctlr_list);
198 static DEFINE_SPINLOCK(list_lock);
199
200 static inline struct rdac_dh_data *get_rdac_data(struct scsi_device *sdev)
201 {
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);
205 }
206
207 static struct request *get_rdac_req(struct scsi_device *sdev,
208                         void *buffer, unsigned buflen, int rw)
209 {
210         struct request *rq;
211         struct request_queue *q = sdev->request_queue;
212
213         rq = blk_get_request(q, rw, GFP_NOIO);
214
215         if (!rq) {
216                 sdev_printk(KERN_INFO, sdev,
217                                 "get_rdac_req: blk_get_request failed.\n");
218                 return NULL;
219         }
220
221         if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
222                 blk_put_request(rq);
223                 sdev_printk(KERN_INFO, sdev,
224                                 "get_rdac_req: blk_rq_map_kern failed.\n");
225                 return NULL;
226         }
227
228         memset(rq->cmd, 0, BLK_MAX_CDB);
229
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;
234
235         return rq;
236 }
237
238 static struct request *rdac_failover_get(struct scsi_device *sdev,
239                                          struct rdac_dh_data *h)
240 {
241         struct request *rq;
242         struct rdac_mode_common *common;
243         unsigned data_size;
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
288         rq->sense = h->sense;
289         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
290         rq->sense_len = 0;
291
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,
336                           unsigned int len, struct rdac_dh_data *h)
337 {
338         struct request *rq;
339         struct request_queue *q = sdev->request_queue;
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);
352
353         rq->sense = h->sense;
354         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
355         rq->sense_len = 0;
356
357         err = blk_execute_rq(q, NULL, rq, 1);
358         if (err == -EIO)
359                 err = SCSI_DH_IO;
360
361         blk_put_request(rq);
362 done:
363         return err;
364 }
365
366 static int get_lun(struct scsi_device *sdev, struct rdac_dh_data *h)
367 {
368         int err;
369         struct c8_inquiry *inqp;
370
371         err = submit_inquiry(sdev, 0xC8, sizeof(struct c8_inquiry), h);
372         if (err == SCSI_DH_OK) {
373                 inqp = &h->inq.c8;
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);
380         }
381         return err;
382 }
383
384 static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
385 {
386         int err;
387         struct c9_inquiry *inqp;
388
389         err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
390         if (err == SCSI_DH_OK) {
391                 inqp = &h->inq.c9;
392                 if ((inqp->avte_cvp >> 7) == 0x1) {
393                         /* LUN in AVT mode */
394                         sdev_printk(KERN_NOTICE, sdev,
395                                     "%s: AVT mode detected\n",
396                                     RDAC_NAME);
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;
401                 }
402         }
403
404         return err;
405 }
406
407 static int initialize_controller(struct scsi_device *sdev,
408                                  struct rdac_dh_data *h)
409 {
410         int err;
411         struct c4_inquiry *inqp;
412
413         err = submit_inquiry(sdev, 0xC4, sizeof(struct c4_inquiry), h);
414         if (err == SCSI_DH_OK) {
415                 inqp = &h->inq.c4;
416                 h->ctlr = get_controller(inqp->subsys_id, inqp->slot_id);
417                 if (!h->ctlr)
418                         err = SCSI_DH_RES_TEMP_UNAVAIL;
419         }
420         return err;
421 }
422
423 static int set_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
424 {
425         int err;
426         struct c2_inquiry *inqp;
427
428         err = submit_inquiry(sdev, 0xC2, sizeof(struct c2_inquiry), h);
429         if (err == SCSI_DH_OK) {
430                 inqp = &h->inq.c2;
431                 /*
432                  * If more than MODE6_MAX_LUN luns are supported, use
433                  * mode select 10
434                  */
435                 if (inqp->max_lun_supported >= MODE6_MAX_LUN)
436                         h->ctlr->use_ms10 = 1;
437                 else
438                         h->ctlr->use_ms10 = 0;
439         }
440         return err;
441 }
442
443 static int mode_select_handle_sense(struct scsi_device *sdev,
444                                     unsigned char *sensebuf)
445 {
446         struct scsi_sense_hdr sense_hdr;
447         int sense, err = SCSI_DH_IO, ret;
448
449         ret = scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE, &sense_hdr);
450         if (!ret)
451                 goto done;
452
453         err = SCSI_DH_OK;
454         sense = (sense_hdr.sense_key << 16) | (sense_hdr.asc << 8) |
455                         sense_hdr.ascq;
456         /* If it is retryable failure, submit the c9 inquiry again */
457         if (sense == 0x59136 || sense == 0x68b02 || sense == 0xb8b02 ||
458                             sense == 0x62900) {
459                 /* 0x59136    - Command lock contention
460                  * 0x[6b]8b02 - Quiesense in progress or achieved
461                  * 0x62900    - Power On, Reset, or Bus Device Reset
462                  */
463                 err = SCSI_DH_RETRY;
464         }
465
466         if (sense)
467                 sdev_printk(KERN_INFO, sdev,
468                         "MODE_SELECT failed with sense 0x%x.\n", sense);
469 done:
470         return err;
471 }
472
473 static int send_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
474 {
475         struct request *rq;
476         struct request_queue *q = sdev->request_queue;
477         int err = SCSI_DH_RES_TEMP_UNAVAIL;
478
479         rq = rdac_failover_get(sdev, h);
480         if (!rq)
481                 goto done;
482
483         sdev_printk(KERN_INFO, sdev, "queueing MODE_SELECT command.\n");
484
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;
490
491         blk_put_request(rq);
492 done:
493         return err;
494 }
495
496 static int rdac_activate(struct scsi_device *sdev)
497 {
498         struct rdac_dh_data *h = get_rdac_data(sdev);
499         int err = SCSI_DH_OK;
500
501         err = check_ownership(sdev, h);
502         if (err != SCSI_DH_OK)
503                 goto done;
504
505         if (!h->ctlr) {
506                 err = initialize_controller(sdev, h);
507                 if (err != SCSI_DH_OK)
508                         goto done;
509         }
510
511         if (h->ctlr->use_ms10 == -1) {
512                 err = set_mode_select(sdev, h);
513                 if (err != SCSI_DH_OK)
514                         goto done;
515         }
516         if (h->lun_state == RDAC_LUN_UNOWNED)
517                 err = send_mode_select(sdev, h);
518 done:
519         return err;
520 }
521
522 static int rdac_prep_fn(struct scsi_device *sdev, struct request *req)
523 {
524         struct rdac_dh_data *h = get_rdac_data(sdev);
525         int ret = BLKPREP_OK;
526
527         if (h->state != RDAC_STATE_ACTIVE) {
528                 ret = BLKPREP_KILL;
529                 req->cmd_flags |= REQ_QUIET;
530         }
531         return ret;
532
533 }
534
535 static int rdac_check_sense(struct scsi_device *sdev,
536                                 struct scsi_sense_hdr *sense_hdr)
537 {
538         struct rdac_dh_data *h = get_rdac_data(sdev);
539         switch (sense_hdr->sense_key) {
540         case NOT_READY:
541                 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x81)
542                         /* LUN Not Ready - Storage firmware incompatible
543                          * Manual code synchonisation required.
544                          *
545                          * Nothing we can do here. Try to bypass the path.
546                          */
547                         return SUCCESS;
548                 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0xA1)
549                         /* LUN Not Ready - Quiescense in progress
550                          *
551                          * Just retry and wait.
552                          */
553                         return NEEDS_RETRY;
554                 break;
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.
560                          */
561                         h->state = RDAC_STATE_PASSIVE;
562                         return SUCCESS;
563                 }
564                 break;
565         case UNIT_ATTENTION:
566                 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
567                         /*
568                          * Power On, Reset, or Bus Device Reset, just retry.
569                          */
570                         return NEEDS_RETRY;
571                 break;
572         }
573         /* success just means we do not care what scsi-ml does */
574         return SCSI_RETURN_NOT_HANDLED;
575 }
576
577 static const struct scsi_dh_devlist rdac_dev_list[] = {
578         {"IBM", "1722"},
579         {"IBM", "1724"},
580         {"IBM", "1726"},
581         {"IBM", "1742"},
582         {"IBM", "1814"},
583         {"IBM", "1815"},
584         {"IBM", "1818"},
585         {"IBM", "3526"},
586         {"SGI", "TP9400"},
587         {"SGI", "TP9500"},
588         {"SGI", "IS"},
589         {"STK", "OPENstorage D280"},
590         {"SUN", "CSM200_R"},
591         {"SUN", "LCSM100_F"},
592         {NULL, NULL},
593 };
594
595 static int rdac_bus_attach(struct scsi_device *sdev);
596 static void rdac_bus_detach(struct scsi_device *sdev);
597
598 static struct scsi_device_handler rdac_dh = {
599         .name = RDAC_NAME,
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,
607 };
608
609 static int rdac_bus_attach(struct scsi_device *sdev)
610 {
611         struct scsi_dh_data *scsi_dh_data;
612         struct rdac_dh_data *h;
613         unsigned long flags;
614         int err;
615
616         scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
617                                + sizeof(*h) , GFP_KERNEL);
618         if (!scsi_dh_data) {
619                 sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
620                             RDAC_NAME);
621                 return 0;
622         }
623
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;
628
629         err = get_lun(sdev, h);
630         if (err != SCSI_DH_OK)
631                 goto failed;
632
633         err = check_ownership(sdev, h);
634         if (err != SCSI_DH_OK)
635                 goto failed;
636
637         if (!try_module_get(THIS_MODULE))
638                 goto failed;
639
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);
643
644         sdev_printk(KERN_NOTICE, sdev,
645                     "%s: LUN %d (%s)\n",
646                     RDAC_NAME, h->lun, lun_state[(int)h->lun_state]);
647
648         return 0;
649
650 failed:
651         kfree(scsi_dh_data);
652         sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
653                     RDAC_NAME);
654         return -EINVAL;
655 }
656
657 static void rdac_bus_detach( struct scsi_device *sdev )
658 {
659         struct scsi_dh_data *scsi_dh_data;
660         struct rdac_dh_data *h;
661         unsigned long flags;
662
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);
667
668         h = (struct rdac_dh_data *) scsi_dh_data->buf;
669         if (h->ctlr)
670                 kref_put(&h->ctlr->kref, release_controller);
671         kfree(scsi_dh_data);
672         module_put(THIS_MODULE);
673         sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", RDAC_NAME);
674 }
675
676
677
678 static int __init rdac_init(void)
679 {
680         int r;
681
682         r = scsi_register_device_handler(&rdac_dh);
683         if (r != 0)
684                 printk(KERN_ERR "Failed to register scsi device handler.");
685         return r;
686 }
687
688 static void __exit rdac_exit(void)
689 {
690         scsi_unregister_device_handler(&rdac_dh);
691 }
692
693 module_init(rdac_init);
694 module_exit(rdac_exit);
695
696 MODULE_DESCRIPTION("Multipath LSI/Engenio RDAC driver");
697 MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
698 MODULE_LICENSE("GPL");