git.oblomov.eu Git - linux-2.6/blob - 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  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2, or (at your option)
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; see the file COPYING.  If not, write to
  20  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #include <scsi/scsi.h>
  24 #include <scsi/scsi_dbg.h>
  25 #include <scsi/scsi_eh.h>
  26 #include <scsi/scsi_dh.h>
  27
  28 #define HP_SW_NAME      "hp_sw"
  29
  30 #define HP_SW_TIMEOUT (60 * HZ)
  31 #define HP_SW_RETRIES 3
  32
  33 struct hp_sw_dh_data {
  34         unsigned char sense[SCSI_SENSE_BUFFERSIZE];
  35         int retries;
  36 };
  37
  38 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
  39 {
  40         struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
  41         BUG_ON(scsi_dh_data == NULL);
  42         return ((struct hp_sw_dh_data *) scsi_dh_data->buf);
  43 }
  44
  45 static int hp_sw_done(struct scsi_device *sdev)
  46 {
  47         struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
  48         struct scsi_sense_hdr sshdr;
  49         int rc;
  50
  51         sdev_printk(KERN_INFO, sdev, "hp_sw_done\n");
  52
  53         rc = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
  54         if (!rc)
  55                 goto done;
  56         switch (sshdr.sense_key) {
  57         case NOT_READY:
  58                 if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
  59                         rc = SCSI_DH_RETRY;
  60                         h->retries++;
  61                         break;
  62                 }
  63                 /* fall through */
  64         default:
  65                 h->retries++;
  66                 rc = SCSI_DH_IMM_RETRY;
  67         }
  68
  69 done:
  70         if (rc == SCSI_DH_OK || rc == SCSI_DH_IO)
  71                 h->retries = 0;
  72         else if (h->retries > HP_SW_RETRIES) {
  73                 h->retries = 0;
  74                 rc = SCSI_DH_IO;
  75         }
  76         return rc;
  77 }
  78
  79 static int hp_sw_activate(struct scsi_device *sdev)
  80 {
  81         struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
  82         struct request *req;
  83         int ret = SCSI_DH_RES_TEMP_UNAVAIL;
  84
  85         req = blk_get_request(sdev->request_queue, WRITE, GFP_ATOMIC);
  86         if (!req)
  87                 goto done;
  88
  89         sdev_printk(KERN_INFO, sdev, "sending START_STOP.");
  90
  91         req->cmd_type = REQ_TYPE_BLOCK_PC;
  92         req->cmd_flags |= REQ_FAILFAST;
  93         req->cmd_len = COMMAND_SIZE(START_STOP);
  94         memset(req->cmd, 0, MAX_COMMAND_SIZE);
  95         req->cmd[0] = START_STOP;
  96         req->cmd[4] = 1;        /* Start spin cycle */
  97         req->timeout = HP_SW_TIMEOUT;
  98         req->sense = h->sense;
  99         memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
 100         req->sense_len = 0;
 101
 102         ret = blk_execute_rq(req->q, NULL, req, 1);
 103         if (!ret) /* SUCCESS */
 104                 ret = hp_sw_done(sdev);
 105         else
 106                 ret = SCSI_DH_IO;
 107 done:
 108         return ret;
 109 }
 110
 111 static const struct {
 112         char *vendor;
 113         char *model;
 114 } hp_sw_dh_data_list[] = {
 115         {"COMPAQ", "MSA"},
 116         {"HP", "HSV"},
 117         {"DEC", "HSG80"},
 118         {NULL, NULL},
 119 };
 120
 121 static int hp_sw_bus_notify(struct notifier_block *, unsigned long, void *);
 122
 123 static struct scsi_device_handler hp_sw_dh = {
 124         .name           = HP_SW_NAME,
 125         .module         = THIS_MODULE,
 126         .nb.notifier_call = hp_sw_bus_notify,
 127         .activate       = hp_sw_activate,
 128 };
 129
 130 static int hp_sw_bus_notify(struct notifier_block *nb,
 131                             unsigned long action, void *data)
 132 {
 133         struct device *dev = data;
 134         struct scsi_device *sdev;
 135         struct scsi_dh_data *scsi_dh_data;
 136         int i, found = 0;
 137         unsigned long flags;
 138
 139         if (!scsi_is_sdev_device(dev))
 140                 return 0;
 141
 142         sdev = to_scsi_device(dev);
 143
 144         if (action == BUS_NOTIFY_ADD_DEVICE) {
 145                 for (i = 0; hp_sw_dh_data_list[i].vendor; i++) {
 146                         if (!strncmp(sdev->vendor, hp_sw_dh_data_list[i].vendor,
 147                                      strlen(hp_sw_dh_data_list[i].vendor)) &&
 148                             !strncmp(sdev->model, hp_sw_dh_data_list[i].model,
 149                                      strlen(hp_sw_dh_data_list[i].model))) {
 150                                 found = 1;
 151                                 break;
 152                         }
 153                 }
 154                 if (!found)
 155                         goto out;
 156
 157                 scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
 158                                 + sizeof(struct hp_sw_dh_data) , GFP_KERNEL);
 159                 if (!scsi_dh_data) {
 160                         sdev_printk(KERN_ERR, sdev, "Attach Failed %s.\n",
 161                                     HP_SW_NAME);
 162                         goto out;
 163                 }
 164
 165                 scsi_dh_data->scsi_dh = &hp_sw_dh;
 166                 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 167                 sdev->scsi_dh_data = scsi_dh_data;
 168                 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 169                 try_module_get(THIS_MODULE);
 170
 171                 sdev_printk(KERN_NOTICE, sdev, "Attached %s.\n", HP_SW_NAME);
 172         } else if (action == BUS_NOTIFY_DEL_DEVICE) {
 173                 if (sdev->scsi_dh_data == NULL ||
 174                                 sdev->scsi_dh_data->scsi_dh != &hp_sw_dh)
 175                         goto out;
 176
 177                 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 178                 scsi_dh_data = sdev->scsi_dh_data;
 179                 sdev->scsi_dh_data = NULL;
 180                 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 181                 module_put(THIS_MODULE);
 182
 183                 sdev_printk(KERN_NOTICE, sdev, "Dettached %s.\n", HP_SW_NAME);
 184
 185                 kfree(scsi_dh_data);
 186         }
 187
 188 out:
 189         return 0;
 190 }
 191
 192 static int __init hp_sw_init(void)
 193 {
 194         return scsi_register_device_handler(&hp_sw_dh);
 195 }
 196
 197 static void __exit hp_sw_exit(void)
 198 {
 199         scsi_unregister_device_handler(&hp_sw_dh);
 200 }
 201
 202 module_init(hp_sw_init);
 203 module_exit(hp_sw_exit);
 204
 205 MODULE_DESCRIPTION("HP MSA 1000");
 206 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
 207 MODULE_LICENSE("GPL");