Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/cooloney...
[linux-2.6] / drivers / scsi / device_handler / scsi_dh_emc.c
1 /*
2  * Target driver for EMC CLARiiON AX/CX-series hardware.
3  * Based on code from Lars Marowsky-Bree <lmb@suse.de>
4  * and Ed Goggin <egoggin@emc.com>.
5  *
6  * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
7  * Copyright (C) 2006 Mike Christie
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2, or (at your option)
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; see the file COPYING.  If not, write to
21  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23 #include <scsi/scsi.h>
24 #include <scsi/scsi_eh.h>
25 #include <scsi/scsi_dh.h>
26 #include <scsi/scsi_device.h>
27
28 #define CLARIION_NAME                   "emc"
29
30 #define CLARIION_TRESPASS_PAGE          0x22
31 #define CLARIION_BUFFER_SIZE            0xFC
32 #define CLARIION_TIMEOUT                (60 * HZ)
33 #define CLARIION_RETRIES                3
34 #define CLARIION_UNBOUND_LU             -1
35 #define CLARIION_SP_A                   0
36 #define CLARIION_SP_B                   1
37
38 /* Flags */
39 #define CLARIION_SHORT_TRESPASS         1
40 #define CLARIION_HONOR_RESERVATIONS     2
41
42 /* LUN states */
43 #define CLARIION_LUN_UNINITIALIZED      -1
44 #define CLARIION_LUN_UNBOUND            0
45 #define CLARIION_LUN_BOUND              1
46 #define CLARIION_LUN_OWNED              2
47
48 static unsigned char long_trespass[] = {
49         0, 0, 0, 0, 0, 0, 0, 0,
50         CLARIION_TRESPASS_PAGE, /* Page code */
51         0x09,                   /* Page length - 2 */
52         0x01,                   /* Trespass code */
53         0xff, 0xff,             /* Trespass target */
54         0, 0, 0, 0, 0, 0        /* Reserved bytes / unknown */
55 };
56
57 static unsigned char short_trespass[] = {
58         0, 0, 0, 0,
59         CLARIION_TRESPASS_PAGE, /* Page code */
60         0x02,                   /* Page length - 2 */
61         0x01,                   /* Trespass code */
62         0xff,                   /* Trespass target */
63 };
64
65 static const char * lun_state[] =
66 {
67     "not bound",
68     "bound",
69     "owned",
70 };
71
72 struct clariion_dh_data {
73         /*
74          * Flags:
75          *  CLARIION_SHORT_TRESPASS
76          * Use short trespass command (FC-series) or the long version
77          * (default for AX/CX CLARiiON arrays).
78          *
79          *  CLARIION_HONOR_RESERVATIONS
80          * Whether or not (default) to honor SCSI reservations when
81          * initiating a switch-over.
82          */
83         unsigned flags;
84         /*
85          * I/O buffer for both MODE_SELECT and INQUIRY commands.
86          */
87         unsigned char buffer[CLARIION_BUFFER_SIZE];
88         /*
89          * SCSI sense buffer for commands -- assumes serial issuance
90          * and completion sequence of all commands for same multipath.
91          */
92         unsigned char sense[SCSI_SENSE_BUFFERSIZE];
93         unsigned int senselen;
94         /*
95          * LUN state
96          */
97         int lun_state;
98         /*
99          * SP Port number
100          */
101         int port;
102         /*
103          * which SP (A=0,B=1,UNBOUND=-1) is the default SP for this
104          * path's mapped LUN
105          */
106         int default_sp;
107         /*
108          * which SP (A=0,B=1,UNBOUND=-1) is the active SP for this
109          * path's mapped LUN
110          */
111         int current_sp;
112 };
113
114 static inline struct clariion_dh_data
115                         *get_clariion_data(struct scsi_device *sdev)
116 {
117         struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
118         BUG_ON(scsi_dh_data == NULL);
119         return ((struct clariion_dh_data *) scsi_dh_data->buf);
120 }
121
122 /*
123  * Parse MODE_SELECT cmd reply.
124  */
125 static int trespass_endio(struct scsi_device *sdev, char *sense)
126 {
127         int err = SCSI_DH_IO;
128         struct scsi_sense_hdr sshdr;
129
130         if (!scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)) {
131                 sdev_printk(KERN_ERR, sdev, "%s: Found valid sense data 0x%2x, "
132                             "0x%2x, 0x%2x while sending CLARiiON trespass "
133                             "command.\n", CLARIION_NAME, sshdr.sense_key,
134                             sshdr.asc, sshdr.ascq);
135
136                 if ((sshdr.sense_key == 0x05) && (sshdr.asc == 0x04) &&
137                      (sshdr.ascq == 0x00)) {
138                         /*
139                          * Array based copy in progress -- do not send
140                          * mode_select or copy will be aborted mid-stream.
141                          */
142                         sdev_printk(KERN_INFO, sdev, "%s: Array Based Copy in "
143                                     "progress while sending CLARiiON trespass "
144                                     "command.\n", CLARIION_NAME);
145                         err = SCSI_DH_DEV_TEMP_BUSY;
146                 } else if ((sshdr.sense_key == 0x02) && (sshdr.asc == 0x04) &&
147                             (sshdr.ascq == 0x03)) {
148                         /*
149                          * LUN Not Ready - Manual Intervention Required
150                          * indicates in-progress ucode upgrade (NDU).
151                          */
152                         sdev_printk(KERN_INFO, sdev, "%s: Detected in-progress "
153                                     "ucode upgrade NDU operation while sending "
154                                     "CLARiiON trespass command.\n", CLARIION_NAME);
155                         err = SCSI_DH_DEV_TEMP_BUSY;
156                 } else
157                         err = SCSI_DH_DEV_FAILED;
158         } else {
159                 sdev_printk(KERN_INFO, sdev,
160                             "%s: failed to send MODE SELECT, no sense available\n",
161                             CLARIION_NAME);
162         }
163         return err;
164 }
165
166 static int parse_sp_info_reply(struct scsi_device *sdev,
167                                struct clariion_dh_data *csdev)
168 {
169         int err = SCSI_DH_OK;
170
171         /* check for in-progress ucode upgrade (NDU) */
172         if (csdev->buffer[48] != 0) {
173                 sdev_printk(KERN_NOTICE, sdev, "%s: Detected in-progress "
174                             "ucode upgrade NDU operation while finding "
175                             "current active SP.", CLARIION_NAME);
176                 err = SCSI_DH_DEV_TEMP_BUSY;
177                 goto out;
178         }
179         if (csdev->buffer[4] > 2) {
180                 /* Invalid buffer format */
181                 sdev_printk(KERN_NOTICE, sdev,
182                             "%s: invalid VPD page 0xC0 format\n",
183                             CLARIION_NAME);
184                 err = SCSI_DH_NOSYS;
185                 goto out;
186         }
187         switch (csdev->buffer[28] & 0x0f) {
188         case 6:
189                 sdev_printk(KERN_NOTICE, sdev,
190                             "%s: ALUA failover mode detected\n",
191                             CLARIION_NAME);
192                 break;
193         case 4:
194                 /* Linux failover */
195                 break;
196         default:
197                 sdev_printk(KERN_WARNING, sdev,
198                             "%s: Invalid failover mode %d\n",
199                             CLARIION_NAME, csdev->buffer[28] & 0x0f);
200                 err = SCSI_DH_NOSYS;
201                 goto out;
202         }
203
204         csdev->default_sp = csdev->buffer[5];
205         csdev->lun_state = csdev->buffer[4];
206         csdev->current_sp = csdev->buffer[8];
207         csdev->port = csdev->buffer[7];
208
209 out:
210         return err;
211 }
212
213 #define emc_default_str "FC (Legacy)"
214
215 static char * parse_sp_model(struct scsi_device *sdev, unsigned char *buffer)
216 {
217         unsigned char len = buffer[4] + 5;
218         char *sp_model = NULL;
219         unsigned char sp_len, serial_len;
220
221         if (len < 160) {
222                 sdev_printk(KERN_WARNING, sdev,
223                             "%s: Invalid information section length %d\n",
224                             CLARIION_NAME, len);
225                 /* Check for old FC arrays */
226                 if (!strncmp(buffer + 8, "DGC", 3)) {
227                         /* Old FC array, not supporting extended information */
228                         sp_model = emc_default_str;
229                 }
230                 goto out;
231         }
232
233         /*
234          * Parse extended information for SP model number
235          */
236         serial_len = buffer[160];
237         if (serial_len == 0 || serial_len + 161 > len) {
238                 sdev_printk(KERN_WARNING, sdev,
239                             "%s: Invalid array serial number length %d\n",
240                             CLARIION_NAME, serial_len);
241                 goto out;
242         }
243         sp_len = buffer[99];
244         if (sp_len == 0 || serial_len + sp_len + 161 > len) {
245                 sdev_printk(KERN_WARNING, sdev,
246                             "%s: Invalid model number length %d\n",
247                             CLARIION_NAME, sp_len);
248                 goto out;
249         }
250         sp_model = &buffer[serial_len + 161];
251         /* Strip whitespace at the end */
252         while (sp_len > 1 && sp_model[sp_len - 1] == ' ')
253                 sp_len--;
254
255         sp_model[sp_len] = '\0';
256
257 out:
258         return sp_model;
259 }
260
261 /*
262  * Get block request for REQ_BLOCK_PC command issued to path.  Currently
263  * limited to MODE_SELECT (trespass) and INQUIRY (VPD page 0xC0) commands.
264  *
265  * Uses data and sense buffers in hardware handler context structure and
266  * assumes serial servicing of commands, both issuance and completion.
267  */
268 static struct request *get_req(struct scsi_device *sdev, int cmd,
269                                 unsigned char *buffer)
270 {
271         struct request *rq;
272         int len = 0;
273
274         rq = blk_get_request(sdev->request_queue,
275                         (cmd == MODE_SELECT) ? WRITE : READ, GFP_NOIO);
276         if (!rq) {
277                 sdev_printk(KERN_INFO, sdev, "get_req: blk_get_request failed");
278                 return NULL;
279         }
280
281         rq->cmd_len = COMMAND_SIZE(cmd);
282         rq->cmd[0] = cmd;
283
284         switch (cmd) {
285         case MODE_SELECT:
286                 len = sizeof(short_trespass);
287                 rq->cmd_flags |= REQ_RW;
288                 rq->cmd[1] = 0x10;
289                 break;
290         case MODE_SELECT_10:
291                 len = sizeof(long_trespass);
292                 rq->cmd_flags |= REQ_RW;
293                 rq->cmd[1] = 0x10;
294                 break;
295         case INQUIRY:
296                 len = CLARIION_BUFFER_SIZE;
297                 memset(buffer, 0, len);
298                 break;
299         default:
300                 BUG_ON(1);
301                 break;
302         }
303
304         rq->cmd[4] = len;
305         rq->cmd_type = REQ_TYPE_BLOCK_PC;
306         rq->cmd_flags |= REQ_FAILFAST;
307         rq->timeout = CLARIION_TIMEOUT;
308         rq->retries = CLARIION_RETRIES;
309
310         if (blk_rq_map_kern(rq->q, rq, buffer, len, GFP_NOIO)) {
311                 blk_put_request(rq);
312                 return NULL;
313         }
314
315         return rq;
316 }
317
318 static int send_inquiry_cmd(struct scsi_device *sdev, int page,
319                             struct clariion_dh_data *csdev)
320 {
321         struct request *rq = get_req(sdev, INQUIRY, csdev->buffer);
322         int err;
323
324         if (!rq)
325                 return SCSI_DH_RES_TEMP_UNAVAIL;
326
327         rq->sense = csdev->sense;
328         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
329         rq->sense_len = csdev->senselen = 0;
330
331         rq->cmd[0] = INQUIRY;
332         if (page != 0) {
333                 rq->cmd[1] = 1;
334                 rq->cmd[2] = page;
335         }
336         err = blk_execute_rq(sdev->request_queue, NULL, rq, 1);
337         if (err == -EIO) {
338                 sdev_printk(KERN_INFO, sdev,
339                             "%s: failed to send %s INQUIRY: %x\n",
340                             CLARIION_NAME, page?"EVPD":"standard",
341                             rq->errors);
342                 csdev->senselen = rq->sense_len;
343                 err = SCSI_DH_IO;
344         }
345
346         blk_put_request(rq);
347
348         return err;
349 }
350
351 static int send_trespass_cmd(struct scsi_device *sdev,
352                             struct clariion_dh_data *csdev)
353 {
354         struct request *rq;
355         unsigned char *page22;
356         int err, len, cmd;
357
358         if (csdev->flags & CLARIION_SHORT_TRESPASS) {
359                 page22 = short_trespass;
360                 if (!(csdev->flags & CLARIION_HONOR_RESERVATIONS))
361                         /* Set Honor Reservations bit */
362                         page22[6] |= 0x80;
363                 len = sizeof(short_trespass);
364                 cmd = MODE_SELECT;
365         } else {
366                 page22 = long_trespass;
367                 if (!(csdev->flags & CLARIION_HONOR_RESERVATIONS))
368                         /* Set Honor Reservations bit */
369                         page22[10] |= 0x80;
370                 len = sizeof(long_trespass);
371                 cmd = MODE_SELECT_10;
372         }
373         BUG_ON((len > CLARIION_BUFFER_SIZE));
374         memcpy(csdev->buffer, page22, len);
375
376         rq = get_req(sdev, cmd, csdev->buffer);
377         if (!rq)
378                 return SCSI_DH_RES_TEMP_UNAVAIL;
379
380         rq->sense = csdev->sense;
381         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
382         rq->sense_len = csdev->senselen = 0;
383
384         err = blk_execute_rq(sdev->request_queue, NULL, rq, 1);
385         if (err == -EIO) {
386                 if (rq->sense_len) {
387                         err = trespass_endio(sdev, csdev->sense);
388                 } else {
389                         sdev_printk(KERN_INFO, sdev,
390                                     "%s: failed to send MODE SELECT: %x\n",
391                                     CLARIION_NAME, rq->errors);
392                 }
393         }
394
395         blk_put_request(rq);
396
397         return err;
398 }
399
400 static int clariion_check_sense(struct scsi_device *sdev,
401                                 struct scsi_sense_hdr *sense_hdr)
402 {
403         switch (sense_hdr->sense_key) {
404         case NOT_READY:
405                 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x03)
406                         /*
407                          * LUN Not Ready - Manual Intervention Required
408                          * indicates this is a passive path.
409                          *
410                          * FIXME: However, if this is seen and EVPD C0
411                          * indicates that this is due to a NDU in
412                          * progress, we should set FAIL_PATH too.
413                          * This indicates we might have to do a SCSI
414                          * inquiry in the end_io path. Ugh.
415                          *
416                          * Can return FAILED only when we want the error
417                          * recovery process to kick in.
418                          */
419                         return SUCCESS;
420                 break;
421         case ILLEGAL_REQUEST:
422                 if (sense_hdr->asc == 0x25 && sense_hdr->ascq == 0x01)
423                         /*
424                          * An array based copy is in progress. Do not
425                          * fail the path, do not bypass to another PG,
426                          * do not retry. Fail the IO immediately.
427                          * (Actually this is the same conclusion as in
428                          * the default handler, but lets make sure.)
429                          *
430                          * Can return FAILED only when we want the error
431                          * recovery process to kick in.
432                          */
433                         return SUCCESS;
434                 break;
435         case UNIT_ATTENTION:
436                 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
437                         /*
438                          * Unit Attention Code. This is the first IO
439                          * to the new path, so just retry.
440                          */
441                         return ADD_TO_MLQUEUE;
442                 break;
443         }
444
445         return SCSI_RETURN_NOT_HANDLED;
446 }
447
448 static int clariion_prep_fn(struct scsi_device *sdev, struct request *req)
449 {
450         struct clariion_dh_data *h = get_clariion_data(sdev);
451         int ret = BLKPREP_OK;
452
453         if (h->lun_state != CLARIION_LUN_OWNED) {
454                 ret = BLKPREP_KILL;
455                 req->cmd_flags |= REQ_QUIET;
456         }
457         return ret;
458
459 }
460
461 static int clariion_std_inquiry(struct scsi_device *sdev,
462                                 struct clariion_dh_data *csdev)
463 {
464         int err;
465         char *sp_model;
466
467         err = send_inquiry_cmd(sdev, 0, csdev);
468         if (err != SCSI_DH_OK && csdev->senselen) {
469                 struct scsi_sense_hdr sshdr;
470
471                 if (scsi_normalize_sense(csdev->sense, SCSI_SENSE_BUFFERSIZE,
472                                          &sshdr)) {
473                         sdev_printk(KERN_ERR, sdev, "%s: INQUIRY sense code "
474                                     "%02x/%02x/%02x\n", CLARIION_NAME,
475                                     sshdr.sense_key, sshdr.asc, sshdr.ascq);
476                 }
477                 err = SCSI_DH_IO;
478                 goto out;
479         }
480
481         sp_model = parse_sp_model(sdev, csdev->buffer);
482         if (!sp_model) {
483                 err = SCSI_DH_DEV_UNSUPP;
484                 goto out;
485         }
486
487         /*
488          * FC Series arrays do not support long trespass
489          */
490         if (!strlen(sp_model) || !strncmp(sp_model, "FC",2))
491                 csdev->flags |= CLARIION_SHORT_TRESPASS;
492
493         sdev_printk(KERN_INFO, sdev,
494                     "%s: detected Clariion %s, flags %x\n",
495                     CLARIION_NAME, sp_model, csdev->flags);
496 out:
497         return err;
498 }
499
500 static int clariion_send_inquiry(struct scsi_device *sdev,
501                                  struct clariion_dh_data *csdev)
502 {
503         int err, retry = CLARIION_RETRIES;
504
505 retry:
506         err = send_inquiry_cmd(sdev, 0xC0, csdev);
507         if (err != SCSI_DH_OK && csdev->senselen) {
508                 struct scsi_sense_hdr sshdr;
509
510                 err = scsi_normalize_sense(csdev->sense, SCSI_SENSE_BUFFERSIZE,
511                                            &sshdr);
512                 if (!err)
513                         return SCSI_DH_IO;
514
515                 err = clariion_check_sense(sdev, &sshdr);
516                 if (retry > 0 && err == ADD_TO_MLQUEUE) {
517                         retry--;
518                         goto retry;
519                 }
520                 sdev_printk(KERN_ERR, sdev, "%s: INQUIRY sense code "
521                             "%02x/%02x/%02x\n", CLARIION_NAME,
522                               sshdr.sense_key, sshdr.asc, sshdr.ascq);
523                 err = SCSI_DH_IO;
524         } else {
525                 err = parse_sp_info_reply(sdev, csdev);
526         }
527         return err;
528 }
529
530 static int clariion_activate(struct scsi_device *sdev)
531 {
532         struct clariion_dh_data *csdev = get_clariion_data(sdev);
533         int result;
534
535         result = clariion_send_inquiry(sdev, csdev);
536         if (result != SCSI_DH_OK)
537                 goto done;
538
539         if (csdev->lun_state == CLARIION_LUN_OWNED)
540                 goto done;
541
542         result = send_trespass_cmd(sdev, csdev);
543         if (result != SCSI_DH_OK)
544                 goto done;
545         sdev_printk(KERN_INFO, sdev,"%s: %s trespass command sent\n",
546                     CLARIION_NAME,
547                     csdev->flags&CLARIION_SHORT_TRESPASS?"short":"long" );
548
549         /* Update status */
550         result = clariion_send_inquiry(sdev, csdev);
551         if (result != SCSI_DH_OK)
552                 goto done;
553
554 done:
555         sdev_printk(KERN_INFO, sdev,
556                     "%s: at SP %c Port %d (%s, default SP %c)\n",
557                     CLARIION_NAME, csdev->current_sp + 'A',
558                     csdev->port, lun_state[csdev->lun_state],
559                     csdev->default_sp + 'A');
560
561         return result;
562 }
563
564 static const struct scsi_dh_devlist clariion_dev_list[] = {
565         {"DGC", "RAID"},
566         {"DGC", "DISK"},
567         {"DGC", "VRAID"},
568         {NULL, NULL},
569 };
570
571 static int clariion_bus_attach(struct scsi_device *sdev);
572 static void clariion_bus_detach(struct scsi_device *sdev);
573
574 static struct scsi_device_handler clariion_dh = {
575         .name           = CLARIION_NAME,
576         .module         = THIS_MODULE,
577         .devlist        = clariion_dev_list,
578         .attach         = clariion_bus_attach,
579         .detach         = clariion_bus_detach,
580         .check_sense    = clariion_check_sense,
581         .activate       = clariion_activate,
582         .prep_fn        = clariion_prep_fn,
583 };
584
585 /*
586  * TODO: need some interface so we can set trespass values
587  */
588 static int clariion_bus_attach(struct scsi_device *sdev)
589 {
590         struct scsi_dh_data *scsi_dh_data;
591         struct clariion_dh_data *h;
592         unsigned long flags;
593         int err;
594
595         scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
596                                + sizeof(*h) , GFP_KERNEL);
597         if (!scsi_dh_data) {
598                 sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
599                             CLARIION_NAME);
600                 return -ENOMEM;
601         }
602
603         scsi_dh_data->scsi_dh = &clariion_dh;
604         h = (struct clariion_dh_data *) scsi_dh_data->buf;
605         h->lun_state = CLARIION_LUN_UNINITIALIZED;
606         h->default_sp = CLARIION_UNBOUND_LU;
607         h->current_sp = CLARIION_UNBOUND_LU;
608
609         err = clariion_std_inquiry(sdev, h);
610         if (err != SCSI_DH_OK)
611                 goto failed;
612
613         err = clariion_send_inquiry(sdev, h);
614         if (err != SCSI_DH_OK)
615                 goto failed;
616
617         if (!try_module_get(THIS_MODULE))
618                 goto failed;
619
620         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
621         sdev->scsi_dh_data = scsi_dh_data;
622         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
623
624         sdev_printk(KERN_INFO, sdev,
625                     "%s: connected to SP %c Port %d (%s, default SP %c)\n",
626                     CLARIION_NAME, h->current_sp + 'A',
627                     h->port, lun_state[h->lun_state],
628                     h->default_sp + 'A');
629
630         return 0;
631
632 failed:
633         kfree(scsi_dh_data);
634         sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
635                     CLARIION_NAME);
636         return -EINVAL;
637 }
638
639 static void clariion_bus_detach(struct scsi_device *sdev)
640 {
641         struct scsi_dh_data *scsi_dh_data;
642         unsigned long flags;
643
644         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
645         scsi_dh_data = sdev->scsi_dh_data;
646         sdev->scsi_dh_data = NULL;
647         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
648
649         sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n",
650                     CLARIION_NAME);
651
652         kfree(scsi_dh_data);
653         module_put(THIS_MODULE);
654 }
655
656 static int __init clariion_init(void)
657 {
658         int r;
659
660         r = scsi_register_device_handler(&clariion_dh);
661         if (r != 0)
662                 printk(KERN_ERR "%s: Failed to register scsi device handler.",
663                         CLARIION_NAME);
664         return r;
665 }
666
667 static void __exit clariion_exit(void)
668 {
669         scsi_unregister_device_handler(&clariion_dh);
670 }
671
672 module_init(clariion_init);
673 module_exit(clariion_exit);
674
675 MODULE_DESCRIPTION("EMC CX/AX/FC-family driver");
676 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, Chandra Seetharaman <sekharan@us.ibm.com>");
677 MODULE_LICENSE("GPL");