drivers/scsi/device_handler/scsi_dh_hp_sw.c

   1 /*
   2  * Basic HP/COMPAQ MSA 1000 support. This is only needed if your HW cannot be
   3  * upgraded.
   4  *
   5  * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
   6  * Copyright (C) 2006 Mike Christie
   7  * Copyright (C) 2008 Hannes Reinecke <hare@suse.de>
   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
  24 #include <scsi/scsi.h>
  25 #include <scsi/scsi_dbg.h>
  26 #include <scsi/scsi_eh.h>
  27 #include <scsi/scsi_dh.h>
  28
  29 #define HP_SW_NAME                      "hp_sw"
  30
  31 #define HP_SW_TIMEOUT                   (60 * HZ)
  32 #define HP_SW_RETRIES                   3
  33
  34 #define HP_SW_PATH_UNINITIALIZED        -1
  35 #define HP_SW_PATH_ACTIVE               0
  36 #define HP_SW_PATH_PASSIVE              1
  37
  38 struct hp_sw_dh_data {
  39         unsigned char sense[SCSI_SENSE_BUFFERSIZE];
  40         int path_state;
  41         int retries;
  42 };
  43
  44 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
  45 {
  46         struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
  47         BUG_ON(scsi_dh_data == NULL);
  48         return ((struct hp_sw_dh_data *) scsi_dh_data->buf);
  49 }
  50
  51 /*
  52  * tur_done - Handle TEST UNIT READY return status
  53  * @sdev: sdev the command has been sent to
  54  * @errors: blk error code
  55  *
  56  * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
  57  */
  58 static int tur_done(struct scsi_device *sdev, unsigned char *sense)
  59 {
  60         struct scsi_sense_hdr sshdr;
  61         int ret;
  62
  63         ret = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
  64         if (!ret) {
  65                 sdev_printk(KERN_WARNING, sdev,
  66                             "%s: sending tur failed, no sense available\n",
  67                             HP_SW_NAME);
  68                 ret = SCSI_DH_IO;
  69                 goto done;
  70         }
  71         switch (sshdr.sense_key) {
  72         case UNIT_ATTENTION:
  73                 ret = SCSI_DH_IMM_RETRY;
  74                 break;
  75         case NOT_READY:
  76                 if ((sshdr.asc == 0x04) && (sshdr.ascq == 2)) {
  77                         /*
  78                          * LUN not ready - Initialization command required
  79                          *
  80                          * This is the passive path
  81                          */
  82                         ret = SCSI_DH_DEV_OFFLINED;
  83                         break;
  84                 }
  85                 /* Fallthrough */
  86         default:
  87                 sdev_printk(KERN_WARNING, sdev,
  88                            "%s: sending tur failed, sense %x/%x/%x\n",
  89                            HP_SW_NAME, sshdr.sense_key, sshdr.asc,
  90                            sshdr.ascq);
  91                 break;
  92         }
  93
  94 done:
  95         return ret;
  96 }
  97
  98 /*
  99  * hp_sw_tur - Send TEST UNIT READY
 100  * @sdev: sdev command should be sent to
 101  *
 102  * Use the TEST UNIT READY command to determine
 103  * the path state.
 104  */
 105 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
 106 {
 107         struct request *req;
 108         int ret;
 109
 110 retry:
 111         req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
 112         if (!req)
 113                 return SCSI_DH_RES_TEMP_UNAVAIL;
 114
 115         req->cmd_type = REQ_TYPE_BLOCK_PC;
 116         req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
 117                           REQ_FAILFAST_DRIVER;
 118         req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY);
 119         req->cmd[0] = TEST_UNIT_READY;
 120         req->timeout = HP_SW_TIMEOUT;
 121         req->sense = h->sense;
 122         memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
 123         req->sense_len = 0;
 124
 125         ret = blk_execute_rq(req->q, NULL, req, 1);
 126         if (ret == -EIO) {
 127                 if (req->sense_len > 0) {
 128                         ret = tur_done(sdev, h->sense);
 129                 } else {
 130                         sdev_printk(KERN_WARNING, sdev,
 131                                     "%s: sending tur failed with %x\n",
 132                                     HP_SW_NAME, req->errors);
 133                         ret = SCSI_DH_IO;
 134                 }
 135         } else {
 136                 h->path_state = HP_SW_PATH_ACTIVE;
 137                 ret = SCSI_DH_OK;
 138         }
 139         if (ret == SCSI_DH_IMM_RETRY) {
 140                 blk_put_request(req);
 141                 goto retry;
 142         }
 143         if (ret == SCSI_DH_DEV_OFFLINED) {
 144                 h->path_state = HP_SW_PATH_PASSIVE;
 145                 ret = SCSI_DH_OK;
 146         }
 147
 148         blk_put_request(req);
 149
 150         return ret;
 151 }
 152
 153 /*
 154  * start_done - Handle START STOP UNIT return status
 155  * @sdev: sdev the command has been sent to
 156  * @errors: blk error code
 157  */
 158 static int start_done(struct scsi_device *sdev, unsigned char *sense)
 159 {
 160         struct scsi_sense_hdr sshdr;
 161         int rc;
 162
 163         rc = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
 164         if (!rc) {
 165                 sdev_printk(KERN_WARNING, sdev,
 166                             "%s: sending start_stop_unit failed, "
 167                             "no sense available\n",
 168                             HP_SW_NAME);
 169                 return SCSI_DH_IO;
 170         }
 171         switch (sshdr.sense_key) {
 172         case NOT_READY:
 173                 if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
 174                         /*
 175                          * LUN not ready - manual intervention required
 176                          *
 177                          * Switch-over in progress, retry.
 178                          */
 179                         rc = SCSI_DH_RETRY;
 180                         break;
 181                 }
 182                 /* fall through */
 183         default:
 184                 sdev_printk(KERN_WARNING, sdev,
 185                            "%s: sending start_stop_unit failed, sense %x/%x/%x\n",
 186                            HP_SW_NAME, sshdr.sense_key, sshdr.asc,
 187                            sshdr.ascq);
 188                 rc = SCSI_DH_IO;
 189         }
 190
 191         return rc;
 192 }
 193
 194 /*
 195  * hp_sw_start_stop - Send START STOP UNIT command
 196  * @sdev: sdev command should be sent to
 197  *
 198  * Sending START STOP UNIT activates the SP.
 199  */
 200 static int hp_sw_start_stop(struct scsi_device *sdev, struct hp_sw_dh_data *h)
 201 {
 202         struct request *req;
 203         int ret, retry;
 204
 205 retry:
 206         req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
 207         if (!req)
 208                 return SCSI_DH_RES_TEMP_UNAVAIL;
 209
 210         req->cmd_type = REQ_TYPE_BLOCK_PC;
 211         req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
 212                           REQ_FAILFAST_DRIVER;
 213         req->cmd_len = COMMAND_SIZE(START_STOP);
 214         req->cmd[0] = START_STOP;
 215         req->cmd[4] = 1;        /* Start spin cycle */
 216         req->timeout = HP_SW_TIMEOUT;
 217         req->sense = h->sense;
 218         memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
 219         req->sense_len = 0;
 220         retry = h->retries;
 221
 222         ret = blk_execute_rq(req->q, NULL, req, 1);
 223         if (ret == -EIO) {
 224                 if (req->sense_len > 0) {
 225                         ret = start_done(sdev, h->sense);
 226                 } else {
 227                         sdev_printk(KERN_WARNING, sdev,
 228                                     "%s: sending start_stop_unit failed with %x\n",
 229                                     HP_SW_NAME, req->errors);
 230                         ret = SCSI_DH_IO;
 231                 }
 232         } else
 233                 ret = SCSI_DH_OK;
 234
 235         if (ret == SCSI_DH_RETRY) {
 236                 if (--retry) {
 237                         blk_put_request(req);
 238                         goto retry;
 239                 }
 240                 ret = SCSI_DH_IO;
 241         }
 242
 243         blk_put_request(req);
 244
 245         return ret;
 246 }
 247
 248 static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
 249 {
 250         struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
 251         int ret = BLKPREP_OK;
 252
 253         if (h->path_state != HP_SW_PATH_ACTIVE) {
 254                 ret = BLKPREP_KILL;
 255                 req->cmd_flags |= REQ_QUIET;
 256         }
 257         return ret;
 258
 259 }
 260
 261 /*
 262  * hp_sw_activate - Activate a path
 263  * @sdev: sdev on the path to be activated
 264  *
 265  * The HP Active/Passive firmware is pretty simple;
 266  * the passive path reports NOT READY with sense codes
 267  * 0x04/0x02; a START STOP UNIT command will then
 268  * activate the passive path (and deactivate the
 269  * previously active one).
 270  */
 271 static int hp_sw_activate(struct scsi_device *sdev)
 272 {
 273         int ret = SCSI_DH_OK;
 274         struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
 275
 276         ret = hp_sw_tur(sdev, h);
 277
 278         if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
 279                 ret = hp_sw_start_stop(sdev, h);
 280                 if (ret == SCSI_DH_OK)
 281                         sdev_printk(KERN_INFO, sdev,
 282                                     "%s: activated path\n",
 283                                     HP_SW_NAME);
 284         }
 285
 286         return ret;
 287 }
 288
 289 static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
 290         {"COMPAQ", "MSA1000 VOLUME"},
 291         {"COMPAQ", "HSV110"},
 292         {"HP", "HSV100"},
 293         {"DEC", "HSG80"},
 294         {NULL, NULL},
 295 };
 296
 297 static int hp_sw_bus_attach(struct scsi_device *sdev);
 298 static void hp_sw_bus_detach(struct scsi_device *sdev);
 299
 300 static struct scsi_device_handler hp_sw_dh = {
 301         .name           = HP_SW_NAME,
 302         .module         = THIS_MODULE,
 303         .devlist        = hp_sw_dh_data_list,
 304         .attach         = hp_sw_bus_attach,
 305         .detach         = hp_sw_bus_detach,
 306         .activate       = hp_sw_activate,
 307         .prep_fn        = hp_sw_prep_fn,
 308 };
 309
 310 static int hp_sw_bus_attach(struct scsi_device *sdev)
 311 {
 312         struct scsi_dh_data *scsi_dh_data;
 313         struct hp_sw_dh_data *h;
 314         unsigned long flags;
 315         int ret;
 316
 317         scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
 318                                + sizeof(struct hp_sw_dh_data) , GFP_KERNEL);
 319         if (!scsi_dh_data) {
 320                 sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
 321                             HP_SW_NAME);
 322                 return 0;
 323         }
 324
 325         scsi_dh_data->scsi_dh = &hp_sw_dh;
 326         h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
 327         h->path_state = HP_SW_PATH_UNINITIALIZED;
 328         h->retries = HP_SW_RETRIES;
 329
 330         ret = hp_sw_tur(sdev, h);
 331         if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
 332                 goto failed;
 333
 334         if (!try_module_get(THIS_MODULE))
 335                 goto failed;
 336
 337         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 338         sdev->scsi_dh_data = scsi_dh_data;
 339         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 340
 341         sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
 342                     HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
 343                     "active":"passive");
 344
 345         return 0;
 346
 347 failed:
 348         kfree(scsi_dh_data);
 349         sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
 350                     HP_SW_NAME);
 351         return -EINVAL;
 352 }
 353
 354 static void hp_sw_bus_detach( struct scsi_device *sdev )
 355 {
 356         struct scsi_dh_data *scsi_dh_data;
 357         unsigned long flags;
 358
 359         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 360         scsi_dh_data = sdev->scsi_dh_data;
 361         sdev->scsi_dh_data = NULL;
 362         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 363         module_put(THIS_MODULE);
 364
 365         sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", HP_SW_NAME);
 366
 367         kfree(scsi_dh_data);
 368 }
 369
 370 static int __init hp_sw_init(void)
 371 {
 372         return scsi_register_device_handler(&hp_sw_dh);
 373 }
 374
 375 static void __exit hp_sw_exit(void)
 376 {
 377         scsi_unregister_device_handler(&hp_sw_dh);
 378 }
 379
 380 module_init(hp_sw_init);
 381 module_exit(hp_sw_exit);
 382
 383 MODULE_DESCRIPTION("HP Active/Passive driver");
 384 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
 385 MODULE_LICENSE("GPL");