2 * Basic HP/COMPAQ MSA 1000 support. This is only needed if your HW cannot be
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>
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)
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.
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.
24 #include <scsi/scsi.h>
25 #include <scsi/scsi_dbg.h>
26 #include <scsi/scsi_eh.h>
27 #include <scsi/scsi_dh.h>
29 #define HP_SW_NAME "hp_sw"
31 #define HP_SW_TIMEOUT (60 * HZ)
32 #define HP_SW_RETRIES 3
34 #define HP_SW_PATH_UNINITIALIZED -1
35 #define HP_SW_PATH_ACTIVE 0
36 #define HP_SW_PATH_PASSIVE 1
38 struct hp_sw_dh_data {
39 unsigned char sense[SCSI_SENSE_BUFFERSIZE];
44 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
46 struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
47 BUG_ON(scsi_dh_data == NULL);
48 return ((struct hp_sw_dh_data *) scsi_dh_data->buf);
52 * tur_done - Handle TEST UNIT READY return status
53 * @sdev: sdev the command has been sent to
54 * @errors: blk error code
56 * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
58 static int tur_done(struct scsi_device *sdev, unsigned char *sense)
60 struct scsi_sense_hdr sshdr;
63 ret = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
65 sdev_printk(KERN_WARNING, sdev,
66 "%s: sending tur failed, no sense available\n",
71 switch (sshdr.sense_key) {
73 ret = SCSI_DH_IMM_RETRY;
76 if ((sshdr.asc == 0x04) && (sshdr.ascq == 2)) {
78 * LUN not ready - Initialization command required
80 * This is the passive path
82 ret = SCSI_DH_DEV_OFFLINED;
87 sdev_printk(KERN_WARNING, sdev,
88 "%s: sending tur failed, sense %x/%x/%x\n",
89 HP_SW_NAME, sshdr.sense_key, sshdr.asc,
99 * hp_sw_tur - Send TEST UNIT READY
100 * @sdev: sdev command should be sent to
102 * Use the TEST UNIT READY command to determine
105 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
110 req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
112 return SCSI_DH_RES_TEMP_UNAVAIL;
114 req->cmd_type = REQ_TYPE_BLOCK_PC;
115 req->cmd_flags |= REQ_FAILFAST;
116 req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY);
117 req->cmd[0] = TEST_UNIT_READY;
118 req->timeout = HP_SW_TIMEOUT;
119 req->sense = h->sense;
120 memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
124 ret = blk_execute_rq(req->q, NULL, req, 1);
126 if (req->sense_len > 0) {
127 ret = tur_done(sdev, h->sense);
129 sdev_printk(KERN_WARNING, sdev,
130 "%s: sending tur failed with %x\n",
131 HP_SW_NAME, req->errors);
135 h->path_state = HP_SW_PATH_ACTIVE;
138 if (ret == SCSI_DH_IMM_RETRY)
140 if (ret == SCSI_DH_DEV_OFFLINED) {
141 h->path_state = HP_SW_PATH_PASSIVE;
145 blk_put_request(req);
151 * start_done - Handle START STOP UNIT return status
152 * @sdev: sdev the command has been sent to
153 * @errors: blk error code
155 static int start_done(struct scsi_device *sdev, unsigned char *sense)
157 struct scsi_sense_hdr sshdr;
160 rc = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
162 sdev_printk(KERN_WARNING, sdev,
163 "%s: sending start_stop_unit failed, "
164 "no sense available\n",
168 switch (sshdr.sense_key) {
170 if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
172 * LUN not ready - manual intervention required
174 * Switch-over in progress, retry.
181 sdev_printk(KERN_WARNING, sdev,
182 "%s: sending start_stop_unit failed, sense %x/%x/%x\n",
183 HP_SW_NAME, sshdr.sense_key, sshdr.asc,
192 * hp_sw_start_stop - Send START STOP UNIT command
193 * @sdev: sdev command should be sent to
195 * Sending START STOP UNIT activates the SP.
197 static int hp_sw_start_stop(struct scsi_device *sdev, struct hp_sw_dh_data *h)
202 req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
204 return SCSI_DH_RES_TEMP_UNAVAIL;
206 req->cmd_type = REQ_TYPE_BLOCK_PC;
207 req->cmd_flags |= REQ_FAILFAST;
208 req->cmd_len = COMMAND_SIZE(START_STOP);
209 req->cmd[0] = START_STOP;
210 req->cmd[4] = 1; /* Start spin cycle */
211 req->timeout = HP_SW_TIMEOUT;
212 req->sense = h->sense;
213 memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
218 ret = blk_execute_rq(req->q, NULL, req, 1);
220 if (req->sense_len > 0) {
221 ret = start_done(sdev, h->sense);
223 sdev_printk(KERN_WARNING, sdev,
224 "%s: sending start_stop_unit failed with %x\n",
225 HP_SW_NAME, req->errors);
231 if (ret == SCSI_DH_RETRY) {
237 blk_put_request(req);
242 static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
244 struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
245 int ret = BLKPREP_OK;
247 if (h->path_state != HP_SW_PATH_ACTIVE) {
249 req->cmd_flags |= REQ_QUIET;
256 * hp_sw_activate - Activate a path
257 * @sdev: sdev on the path to be activated
259 * The HP Active/Passive firmware is pretty simple;
260 * the passive path reports NOT READY with sense codes
261 * 0x04/0x02; a START STOP UNIT command will then
262 * activate the passive path (and deactivate the
263 * previously active one).
265 static int hp_sw_activate(struct scsi_device *sdev)
267 int ret = SCSI_DH_OK;
268 struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
270 ret = hp_sw_tur(sdev, h);
272 if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
273 ret = hp_sw_start_stop(sdev, h);
274 if (ret == SCSI_DH_OK)
275 sdev_printk(KERN_INFO, sdev,
276 "%s: activated path\n",
283 static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
284 {"COMPAQ", "MSA1000 VOLUME"},
285 {"COMPAQ", "HSV110"},
291 static int hp_sw_bus_attach(struct scsi_device *sdev);
292 static void hp_sw_bus_detach(struct scsi_device *sdev);
294 static struct scsi_device_handler hp_sw_dh = {
296 .module = THIS_MODULE,
297 .devlist = hp_sw_dh_data_list,
298 .attach = hp_sw_bus_attach,
299 .detach = hp_sw_bus_detach,
300 .activate = hp_sw_activate,
301 .prep_fn = hp_sw_prep_fn,
304 static int hp_sw_bus_attach(struct scsi_device *sdev)
306 struct scsi_dh_data *scsi_dh_data;
307 struct hp_sw_dh_data *h;
311 scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
312 + sizeof(struct hp_sw_dh_data) , GFP_KERNEL);
314 sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
319 scsi_dh_data->scsi_dh = &hp_sw_dh;
320 h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
321 h->path_state = HP_SW_PATH_UNINITIALIZED;
322 h->retries = HP_SW_RETRIES;
324 ret = hp_sw_tur(sdev, h);
325 if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
328 if (!try_module_get(THIS_MODULE))
331 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
332 sdev->scsi_dh_data = scsi_dh_data;
333 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
335 sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
336 HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
343 sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
348 static void hp_sw_bus_detach( struct scsi_device *sdev )
350 struct scsi_dh_data *scsi_dh_data;
353 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
354 scsi_dh_data = sdev->scsi_dh_data;
355 sdev->scsi_dh_data = NULL;
356 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
357 module_put(THIS_MODULE);
359 sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", HP_SW_NAME);
364 static int __init hp_sw_init(void)
366 return scsi_register_device_handler(&hp_sw_dh);
369 static void __exit hp_sw_exit(void)
371 scsi_unregister_device_handler(&hp_sw_dh);
374 module_init(hp_sw_init);
375 module_exit(hp_sw_exit);
377 MODULE_DESCRIPTION("HP Active/Passive driver");
378 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
379 MODULE_LICENSE("GPL");