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