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         int path_state;
  42         int retries;
  43         int retry_cnt;
  44         struct scsi_device *sdev;
  45 };
  46
  47 static int hp_sw_start_stop(struct hp_sw_dh_data *);
  48
  49 /*
  50  * tur_done - Handle TEST UNIT READY return status
  51  * @sdev: sdev the command has been sent to
  52  * @errors: blk error code
  53  *
  54  * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
  55  */
  56 static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
  57                     struct scsi_sense_hdr *sshdr)
  58 {
  59         int ret = SCSI_DH_IO;
  60
  61         switch (sshdr->sense_key) {
  62         case UNIT_ATTENTION:
  63                 ret = SCSI_DH_IMM_RETRY;
  64                 break;
  65         case NOT_READY:
  66                 if (sshdr->asc == 0x04 && sshdr->ascq == 2) {
  67                         /*
  68                          * LUN not ready - Initialization command required
  69                          *
  70                          * This is the passive path
  71                          */
  72                         h->path_state = HP_SW_PATH_PASSIVE;
  73                         ret = SCSI_DH_OK;
  74                         break;
  75                 }
  76                 /* Fallthrough */
  77         default:
  78                 sdev_printk(KERN_WARNING, sdev,
  79                            "%s: sending tur failed, sense %x/%x/%x\n",
  80                            HP_SW_NAME, sshdr->sense_key, sshdr->asc,
  81                            sshdr->ascq);
  82                 break;
  83         }
  84         return ret;
  85 }
  86
  87 /*
  88  * hp_sw_tur - Send TEST UNIT READY
  89  * @sdev: sdev command should be sent to
  90  *
  91  * Use the TEST UNIT READY command to determine
  92  * the path state.
  93  */
  94 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
  95 {
  96         unsigned char cmd[6] = { TEST_UNIT_READY };
  97         struct scsi_sense_hdr sshdr;
  98         int ret = SCSI_DH_OK, res;
  99         u64 req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
 100                 REQ_FAILFAST_DRIVER;
 101
 102 retry:
 103         res = scsi_execute(sdev, cmd, DMA_NONE, NULL, 0, NULL, &sshdr,
 104                         HP_SW_TIMEOUT, HP_SW_RETRIES, req_flags, 0, NULL);
 105         if (res) {
 106                 if (scsi_sense_valid(&sshdr))
 107                         ret = tur_done(sdev, h, &sshdr);
 108                 else {
 109                         sdev_printk(KERN_WARNING, sdev,
 110                                     "%s: sending tur failed with %x\n",
 111                                     HP_SW_NAME, res);
 112                         ret = SCSI_DH_IO;
 113                 }
 114         } else {
 115                 h->path_state = HP_SW_PATH_ACTIVE;
 116                 ret = SCSI_DH_OK;
 117         }
 118         if (ret == SCSI_DH_IMM_RETRY)
 119                 goto retry;
 120
 121         return ret;
 122 }
 123
 124 /*
 125  * hp_sw_start_stop - Send START STOP UNIT command
 126  * @sdev: sdev command should be sent to
 127  *
 128  * Sending START STOP UNIT activates the SP.
 129  */
 130 static int hp_sw_start_stop(struct hp_sw_dh_data *h)
 131 {
 132         unsigned char cmd[6] = { START_STOP, 0, 0, 0, 1, 0 };
 133         struct scsi_sense_hdr sshdr;
 134         struct scsi_device *sdev = h->sdev;
 135         int res, rc = SCSI_DH_OK;
 136         int retry_cnt = HP_SW_RETRIES;
 137         u64 req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
 138                 REQ_FAILFAST_DRIVER;
 139
 140 retry:
 141         res = scsi_execute(sdev, cmd, DMA_NONE, NULL, 0, NULL, &sshdr,
 142                         HP_SW_TIMEOUT, HP_SW_RETRIES, req_flags, 0, NULL);
 143         if (res) {
 144                 if (!scsi_sense_valid(&sshdr)) {
 145                         sdev_printk(KERN_WARNING, sdev,
 146                                     "%s: sending start_stop_unit failed, "
 147                                     "no sense available\n", HP_SW_NAME);
 148                         return SCSI_DH_IO;
 149                 }
 150                 switch (sshdr.sense_key) {
 151                 case NOT_READY:
 152                         if (sshdr.asc == 0x04 && sshdr.ascq == 3) {
 153                                 /*
 154                                  * LUN not ready - manual intervention required
 155                                  *
 156                                  * Switch-over in progress, retry.
 157                                  */
 158                                 if (--retry_cnt)
 159                                         goto retry;
 160                                 rc = SCSI_DH_RETRY;
 161                                 break;
 162                         }
 163                         /* fall through */
 164                 default:
 165                         sdev_printk(KERN_WARNING, sdev,
 166                                     "%s: sending start_stop_unit failed, "
 167                                     "sense %x/%x/%x\n", HP_SW_NAME,
 168                                     sshdr.sense_key, sshdr.asc, sshdr.ascq);
 169                         rc = SCSI_DH_IO;
 170                 }
 171         }
 172         return rc;
 173 }
 174
 175 static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
 176 {
 177         struct hp_sw_dh_data *h = sdev->handler_data;
 178         int ret = BLKPREP_OK;
 179
 180         if (h->path_state != HP_SW_PATH_ACTIVE) {
 181                 ret = BLKPREP_KILL;
 182                 req->rq_flags |= RQF_QUIET;
 183         }
 184         return ret;
 185
 186 }
 187
 188 /*
 189  * hp_sw_activate - Activate a path
 190  * @sdev: sdev on the path to be activated
 191  *
 192  * The HP Active/Passive firmware is pretty simple;
 193  * the passive path reports NOT READY with sense codes
 194  * 0x04/0x02; a START STOP UNIT command will then
 195  * activate the passive path (and deactivate the
 196  * previously active one).
 197  */
 198 static int hp_sw_activate(struct scsi_device *sdev,
 199                                 activate_complete fn, void *data)
 200 {
 201         int ret = SCSI_DH_OK;
 202         struct hp_sw_dh_data *h = sdev->handler_data;
 203
 204         ret = hp_sw_tur(sdev, h);
 205
 206         if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE)
 207                 ret = hp_sw_start_stop(h);
 208
 209         if (fn)
 210                 fn(data, ret);
 211         return 0;
 212 }
 213
 214 static int hp_sw_bus_attach(struct scsi_device *sdev)
 215 {
 216         struct hp_sw_dh_data *h;
 217         int ret;
 218
 219         h = kzalloc(sizeof(*h), GFP_KERNEL);
 220         if (!h)
 221                 return SCSI_DH_NOMEM;
 222         h->path_state = HP_SW_PATH_UNINITIALIZED;
 223         h->retries = HP_SW_RETRIES;
 224         h->sdev = sdev;
 225
 226         ret = hp_sw_tur(sdev, h);
 227         if (ret != SCSI_DH_OK)
 228                 goto failed;
 229         if (h->path_state == HP_SW_PATH_UNINITIALIZED) {
 230                 ret = SCSI_DH_NOSYS;
 231                 goto failed;
 232         }
 233
 234         sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
 235                     HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
 236                     "active":"passive");
 237
 238         sdev->handler_data = h;
 239         return SCSI_DH_OK;
 240 failed:
 241         kfree(h);
 242         return ret;
 243 }
 244
 245 static void hp_sw_bus_detach( struct scsi_device *sdev )
 246 {
 247         kfree(sdev->handler_data);
 248         sdev->handler_data = NULL;
 249 }
 250
 251 static struct scsi_device_handler hp_sw_dh = {
 252         .name           = HP_SW_NAME,
 253         .module         = THIS_MODULE,
 254         .attach         = hp_sw_bus_attach,
 255         .detach         = hp_sw_bus_detach,
 256         .activate       = hp_sw_activate,
 257         .prep_fn        = hp_sw_prep_fn,
 258 };
 259
 260 static int __init hp_sw_init(void)
 261 {
 262         return scsi_register_device_handler(&hp_sw_dh);
 263 }
 264
 265 static void __exit hp_sw_exit(void)
 266 {
 267         scsi_unregister_device_handler(&hp_sw_dh);
 268 }
 269
 270 module_init(hp_sw_init);
 271 module_exit(hp_sw_exit);
 272
 273 MODULE_DESCRIPTION("HP Active/Passive driver");
 274 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
 275 MODULE_LICENSE("GPL");