drivers/scsi/device_handler/scsi_dh_hp_sw.c

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