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