Staging: strip: delete the driver
[linux/fpc-iii.git] / drivers / scsi / device_handler / scsi_dh_hp_sw.c
blobe3916641e627883418d18b4eeb94bcbe1ddec018
1 /*
2 * Basic HP/COMPAQ MSA 1000 support. This is only needed if your HW cannot be
3 * upgraded.
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)
12 * any later version.
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 <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>
30 #define HP_SW_NAME "hp_sw"
32 #define HP_SW_TIMEOUT (60 * HZ)
33 #define HP_SW_RETRIES 3
35 #define HP_SW_PATH_UNINITIALIZED -1
36 #define HP_SW_PATH_ACTIVE 0
37 #define HP_SW_PATH_PASSIVE 1
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;
49 static int hp_sw_start_stop(struct hp_sw_dh_data *);
51 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
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);
59 * tur_done - Handle TEST UNIT READY return status
60 * @sdev: sdev the command has been sent to
61 * @errors: blk error code
63 * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
65 static int tur_done(struct scsi_device *sdev, unsigned char *sense)
67 struct scsi_sense_hdr sshdr;
68 int ret;
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;
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)) {
85 * LUN not ready - Initialization command required
87 * This is the passive path
89 ret = SCSI_DH_DEV_OFFLINED;
90 break;
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;
101 done:
102 return ret;
106 * hp_sw_tur - Send TEST UNIT READY
107 * @sdev: sdev command should be sent to
109 * Use the TEST UNIT READY command to determine
110 * the path state.
112 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
114 struct request *req;
115 int ret;
117 retry:
118 req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
119 if (!req)
120 return SCSI_DH_RES_TEMP_UNAVAIL;
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;
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;
142 } else {
143 h->path_state = HP_SW_PATH_ACTIVE;
144 ret = SCSI_DH_OK;
146 if (ret == SCSI_DH_IMM_RETRY) {
147 blk_put_request(req);
148 goto retry;
150 if (ret == SCSI_DH_DEV_OFFLINED) {
151 h->path_state = HP_SW_PATH_PASSIVE;
152 ret = SCSI_DH_OK;
155 blk_put_request(req);
157 return ret;
161 * start_done - Handle START STOP UNIT return status
162 * @sdev: sdev the command has been sent to
163 * @errors: blk error code
165 static int start_done(struct scsi_device *sdev, unsigned char *sense)
167 struct scsi_sense_hdr sshdr;
168 int rc;
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;
178 switch (sshdr.sense_key) {
179 case NOT_READY:
180 if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
182 * LUN not ready - manual intervention required
184 * Switch-over in progress, retry.
186 rc = SCSI_DH_RETRY;
187 break;
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;
198 return rc;
201 static void start_stop_endio(struct request *req, int error)
203 struct hp_sw_dh_data *h = req->end_io_data;
204 unsigned err = SCSI_DH_OK;
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;
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;
227 done:
228 blk_put_request(req);
229 if (h->callback_fn) {
230 h->callback_fn(h->callback_data, err);
231 h->callback_fn = h->callback_data = NULL;
233 return;
238 * hp_sw_start_stop - Send START STOP UNIT command
239 * @sdev: sdev command should be sent to
241 * Sending START STOP UNIT activates the SP.
243 static int hp_sw_start_stop(struct hp_sw_dh_data *h)
245 struct request *req;
247 req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
248 if (!req)
249 return SCSI_DH_RES_TEMP_UNAVAIL;
251 req->cmd_type = REQ_TYPE_BLOCK_PC;
252 req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
253 REQ_FAILFAST_DRIVER;
254 req->cmd_len = COMMAND_SIZE(START_STOP);
255 req->cmd[0] = START_STOP;
256 req->cmd[4] = 1; /* Start spin cycle */
257 req->timeout = HP_SW_TIMEOUT;
258 req->sense = h->sense;
259 memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
260 req->sense_len = 0;
261 req->end_io_data = h;
263 blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
264 return SCSI_DH_OK;
267 static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
269 struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
270 int ret = BLKPREP_OK;
272 if (h->path_state != HP_SW_PATH_ACTIVE) {
273 ret = BLKPREP_KILL;
274 req->cmd_flags |= REQ_QUIET;
276 return ret;
281 * hp_sw_activate - Activate a path
282 * @sdev: sdev on the path to be activated
284 * The HP Active/Passive firmware is pretty simple;
285 * the passive path reports NOT READY with sense codes
286 * 0x04/0x02; a START STOP UNIT command will then
287 * activate the passive path (and deactivate the
288 * previously active one).
290 static int hp_sw_activate(struct scsi_device *sdev,
291 activate_complete fn, void *data)
293 int ret = SCSI_DH_OK;
294 struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
296 ret = hp_sw_tur(sdev, h);
298 if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
299 h->retry_cnt = h->retries;
300 h->callback_fn = fn;
301 h->callback_data = data;
302 ret = hp_sw_start_stop(h);
303 if (ret == SCSI_DH_OK)
304 return 0;
305 h->callback_fn = h->callback_data = NULL;
308 if (fn)
309 fn(data, ret);
310 return 0;
313 static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
314 {"COMPAQ", "MSA1000 VOLUME"},
315 {"COMPAQ", "HSV110"},
316 {"HP", "HSV100"},
317 {"DEC", "HSG80"},
318 {NULL, NULL},
321 static int hp_sw_bus_attach(struct scsi_device *sdev);
322 static void hp_sw_bus_detach(struct scsi_device *sdev);
324 static struct scsi_device_handler hp_sw_dh = {
325 .name = HP_SW_NAME,
326 .module = THIS_MODULE,
327 .devlist = hp_sw_dh_data_list,
328 .attach = hp_sw_bus_attach,
329 .detach = hp_sw_bus_detach,
330 .activate = hp_sw_activate,
331 .prep_fn = hp_sw_prep_fn,
334 static int hp_sw_bus_attach(struct scsi_device *sdev)
336 struct scsi_dh_data *scsi_dh_data;
337 struct hp_sw_dh_data *h;
338 unsigned long flags;
339 int ret;
341 scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
342 + sizeof(struct hp_sw_dh_data) , GFP_KERNEL);
343 if (!scsi_dh_data) {
344 sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
345 HP_SW_NAME);
346 return 0;
349 scsi_dh_data->scsi_dh = &hp_sw_dh;
350 h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
351 h->path_state = HP_SW_PATH_UNINITIALIZED;
352 h->retries = HP_SW_RETRIES;
353 h->sdev = sdev;
355 ret = hp_sw_tur(sdev, h);
356 if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
357 goto failed;
359 if (!try_module_get(THIS_MODULE))
360 goto failed;
362 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
363 sdev->scsi_dh_data = scsi_dh_data;
364 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
366 sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
367 HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
368 "active":"passive");
370 return 0;
372 failed:
373 kfree(scsi_dh_data);
374 sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
375 HP_SW_NAME);
376 return -EINVAL;
379 static void hp_sw_bus_detach( struct scsi_device *sdev )
381 struct scsi_dh_data *scsi_dh_data;
382 unsigned long flags;
384 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
385 scsi_dh_data = sdev->scsi_dh_data;
386 sdev->scsi_dh_data = NULL;
387 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
388 module_put(THIS_MODULE);
390 sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", HP_SW_NAME);
392 kfree(scsi_dh_data);
395 static int __init hp_sw_init(void)
397 return scsi_register_device_handler(&hp_sw_dh);
400 static void __exit hp_sw_exit(void)
402 scsi_unregister_device_handler(&hp_sw_dh);
405 module_init(hp_sw_init);
406 module_exit(hp_sw_exit);
408 MODULE_DESCRIPTION("HP Active/Passive driver");
409 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
410 MODULE_LICENSE("GPL");