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