Loading...
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 <scsi/scsi.h>
26#include <scsi/scsi_dbg.h>
27#include <scsi/scsi_eh.h>
28#include <scsi/scsi_dh.h>
29
30#define HP_SW_NAME "hp_sw"
31
32#define HP_SW_TIMEOUT (60 * HZ)
33#define HP_SW_RETRIES 3
34
35#define HP_SW_PATH_UNINITIALIZED -1
36#define HP_SW_PATH_ACTIVE 0
37#define HP_SW_PATH_PASSIVE 1
38
39struct 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;
47};
48
49static int hp_sw_start_stop(struct hp_sw_dh_data *);
50
51static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
52{
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);
56}
57
58/*
59 * tur_done - Handle TEST UNIT READY return status
60 * @sdev: sdev the command has been sent to
61 * @errors: blk error code
62 *
63 * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
64 */
65static int tur_done(struct scsi_device *sdev, unsigned char *sense)
66{
67 struct scsi_sense_hdr sshdr;
68 int ret;
69
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;
77 }
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)) {
84 /*
85 * LUN not ready - Initialization command required
86 *
87 * This is the passive path
88 */
89 ret = SCSI_DH_DEV_OFFLINED;
90 break;
91 }
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;
99 }
100
101done:
102 return ret;
103}
104
105/*
106 * hp_sw_tur - Send TEST UNIT READY
107 * @sdev: sdev command should be sent to
108 *
109 * Use the TEST UNIT READY command to determine
110 * the path state.
111 */
112static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
113{
114 struct request *req;
115 int ret;
116
117retry:
118 req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
119 if (!req)
120 return SCSI_DH_RES_TEMP_UNAVAIL;
121
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;
131
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;
141 }
142 } else {
143 h->path_state = HP_SW_PATH_ACTIVE;
144 ret = SCSI_DH_OK;
145 }
146 if (ret == SCSI_DH_IMM_RETRY) {
147 blk_put_request(req);
148 goto retry;
149 }
150 if (ret == SCSI_DH_DEV_OFFLINED) {
151 h->path_state = HP_SW_PATH_PASSIVE;
152 ret = SCSI_DH_OK;
153 }
154
155 blk_put_request(req);
156
157 return ret;
158}
159
160/*
161 * start_done - Handle START STOP UNIT return status
162 * @sdev: sdev the command has been sent to
163 * @errors: blk error code
164 */
165static int start_done(struct scsi_device *sdev, unsigned char *sense)
166{
167 struct scsi_sense_hdr sshdr;
168 int rc;
169
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;
177 }
178 switch (sshdr.sense_key) {
179 case NOT_READY:
180 if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
181 /*
182 * LUN not ready - manual intervention required
183 *
184 * Switch-over in progress, retry.
185 */
186 rc = SCSI_DH_RETRY;
187 break;
188 }
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;
196 }
197
198 return rc;
199}
200
201static void start_stop_endio(struct request *req, int error)
202{
203 struct hp_sw_dh_data *h = req->end_io_data;
204 unsigned err = SCSI_DH_OK;
205
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;
213 }
214
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;
224 }
225 }
226 }
227done:
228 req->end_io_data = NULL;
229 __blk_put_request(req->q, req);
230 if (h->callback_fn) {
231 h->callback_fn(h->callback_data, err);
232 h->callback_fn = h->callback_data = NULL;
233 }
234 return;
235
236}
237
238/*
239 * hp_sw_start_stop - Send START STOP UNIT command
240 * @sdev: sdev command should be sent to
241 *
242 * Sending START STOP UNIT activates the SP.
243 */
244static int hp_sw_start_stop(struct hp_sw_dh_data *h)
245{
246 struct request *req;
247
248 req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
249 if (!req)
250 return SCSI_DH_RES_TEMP_UNAVAIL;
251
252 req->cmd_type = REQ_TYPE_BLOCK_PC;
253 req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
254 REQ_FAILFAST_DRIVER;
255 req->cmd_len = COMMAND_SIZE(START_STOP);
256 req->cmd[0] = START_STOP;
257 req->cmd[4] = 1; /* Start spin cycle */
258 req->timeout = HP_SW_TIMEOUT;
259 req->sense = h->sense;
260 memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
261 req->sense_len = 0;
262 req->end_io_data = h;
263
264 blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
265 return SCSI_DH_OK;
266}
267
268static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
269{
270 struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
271 int ret = BLKPREP_OK;
272
273 if (h->path_state != HP_SW_PATH_ACTIVE) {
274 ret = BLKPREP_KILL;
275 req->cmd_flags |= REQ_QUIET;
276 }
277 return ret;
278
279}
280
281/*
282 * hp_sw_activate - Activate a path
283 * @sdev: sdev on the path to be activated
284 *
285 * The HP Active/Passive firmware is pretty simple;
286 * the passive path reports NOT READY with sense codes
287 * 0x04/0x02; a START STOP UNIT command will then
288 * activate the passive path (and deactivate the
289 * previously active one).
290 */
291static int hp_sw_activate(struct scsi_device *sdev,
292 activate_complete fn, void *data)
293{
294 int ret = SCSI_DH_OK;
295 struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
296
297 ret = hp_sw_tur(sdev, h);
298
299 if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
300 h->retry_cnt = h->retries;
301 h->callback_fn = fn;
302 h->callback_data = data;
303 ret = hp_sw_start_stop(h);
304 if (ret == SCSI_DH_OK)
305 return 0;
306 h->callback_fn = h->callback_data = NULL;
307 }
308
309 if (fn)
310 fn(data, ret);
311 return 0;
312}
313
314static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
315 {"COMPAQ", "MSA1000 VOLUME"},
316 {"COMPAQ", "HSV110"},
317 {"HP", "HSV100"},
318 {"DEC", "HSG80"},
319 {NULL, NULL},
320};
321
322static int hp_sw_bus_attach(struct scsi_device *sdev);
323static void hp_sw_bus_detach(struct scsi_device *sdev);
324
325static struct scsi_device_handler hp_sw_dh = {
326 .name = HP_SW_NAME,
327 .module = THIS_MODULE,
328 .devlist = hp_sw_dh_data_list,
329 .attach = hp_sw_bus_attach,
330 .detach = hp_sw_bus_detach,
331 .activate = hp_sw_activate,
332 .prep_fn = hp_sw_prep_fn,
333};
334
335static int hp_sw_bus_attach(struct scsi_device *sdev)
336{
337 struct scsi_dh_data *scsi_dh_data;
338 struct hp_sw_dh_data *h;
339 unsigned long flags;
340 int ret;
341
342 scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
343 + sizeof(*h) , GFP_KERNEL);
344 if (!scsi_dh_data) {
345 sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
346 HP_SW_NAME);
347 return 0;
348 }
349
350 scsi_dh_data->scsi_dh = &hp_sw_dh;
351 h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
352 h->path_state = HP_SW_PATH_UNINITIALIZED;
353 h->retries = HP_SW_RETRIES;
354 h->sdev = sdev;
355
356 ret = hp_sw_tur(sdev, h);
357 if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
358 goto failed;
359
360 if (!try_module_get(THIS_MODULE))
361 goto failed;
362
363 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
364 sdev->scsi_dh_data = scsi_dh_data;
365 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
366
367 sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
368 HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
369 "active":"passive");
370
371 return 0;
372
373failed:
374 kfree(scsi_dh_data);
375 sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
376 HP_SW_NAME);
377 return -EINVAL;
378}
379
380static void hp_sw_bus_detach( struct scsi_device *sdev )
381{
382 struct scsi_dh_data *scsi_dh_data;
383 unsigned long flags;
384
385 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
386 scsi_dh_data = sdev->scsi_dh_data;
387 sdev->scsi_dh_data = NULL;
388 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
389 module_put(THIS_MODULE);
390
391 sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", HP_SW_NAME);
392
393 kfree(scsi_dh_data);
394}
395
396static int __init hp_sw_init(void)
397{
398 return scsi_register_device_handler(&hp_sw_dh);
399}
400
401static void __exit hp_sw_exit(void)
402{
403 scsi_unregister_device_handler(&hp_sw_dh);
404}
405
406module_init(hp_sw_init);
407module_exit(hp_sw_exit);
408
409MODULE_DESCRIPTION("HP Active/Passive driver");
410MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
411MODULE_LICENSE("GPL");
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
40struct hp_sw_dh_data {
41 unsigned char sense[SCSI_SENSE_BUFFERSIZE];
42 int path_state;
43 int retries;
44 int retry_cnt;
45 struct scsi_device *sdev;
46 activate_complete callback_fn;
47 void *callback_data;
48};
49
50static int hp_sw_start_stop(struct hp_sw_dh_data *);
51
52static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
53{
54 struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
55 BUG_ON(scsi_dh_data == NULL);
56 return ((struct hp_sw_dh_data *) scsi_dh_data->buf);
57}
58
59/*
60 * tur_done - Handle TEST UNIT READY return status
61 * @sdev: sdev the command has been sent to
62 * @errors: blk error code
63 *
64 * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path
65 */
66static int tur_done(struct scsi_device *sdev, unsigned char *sense)
67{
68 struct scsi_sense_hdr sshdr;
69 int ret;
70
71 ret = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
72 if (!ret) {
73 sdev_printk(KERN_WARNING, sdev,
74 "%s: sending tur failed, no sense available\n",
75 HP_SW_NAME);
76 ret = SCSI_DH_IO;
77 goto done;
78 }
79 switch (sshdr.sense_key) {
80 case UNIT_ATTENTION:
81 ret = SCSI_DH_IMM_RETRY;
82 break;
83 case NOT_READY:
84 if ((sshdr.asc == 0x04) && (sshdr.ascq == 2)) {
85 /*
86 * LUN not ready - Initialization command required
87 *
88 * This is the passive path
89 */
90 ret = SCSI_DH_DEV_OFFLINED;
91 break;
92 }
93 /* Fallthrough */
94 default:
95 sdev_printk(KERN_WARNING, sdev,
96 "%s: sending tur failed, sense %x/%x/%x\n",
97 HP_SW_NAME, sshdr.sense_key, sshdr.asc,
98 sshdr.ascq);
99 break;
100 }
101
102done:
103 return ret;
104}
105
106/*
107 * hp_sw_tur - Send TEST UNIT READY
108 * @sdev: sdev command should be sent to
109 *
110 * Use the TEST UNIT READY command to determine
111 * the path state.
112 */
113static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
114{
115 struct request *req;
116 int ret;
117
118retry:
119 req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
120 if (!req)
121 return SCSI_DH_RES_TEMP_UNAVAIL;
122
123 req->cmd_type = REQ_TYPE_BLOCK_PC;
124 req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
125 REQ_FAILFAST_DRIVER;
126 req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY);
127 req->cmd[0] = TEST_UNIT_READY;
128 req->timeout = HP_SW_TIMEOUT;
129 req->sense = h->sense;
130 memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
131 req->sense_len = 0;
132
133 ret = blk_execute_rq(req->q, NULL, req, 1);
134 if (ret == -EIO) {
135 if (req->sense_len > 0) {
136 ret = tur_done(sdev, h->sense);
137 } else {
138 sdev_printk(KERN_WARNING, sdev,
139 "%s: sending tur failed with %x\n",
140 HP_SW_NAME, req->errors);
141 ret = SCSI_DH_IO;
142 }
143 } else {
144 h->path_state = HP_SW_PATH_ACTIVE;
145 ret = SCSI_DH_OK;
146 }
147 if (ret == SCSI_DH_IMM_RETRY) {
148 blk_put_request(req);
149 goto retry;
150 }
151 if (ret == SCSI_DH_DEV_OFFLINED) {
152 h->path_state = HP_SW_PATH_PASSIVE;
153 ret = SCSI_DH_OK;
154 }
155
156 blk_put_request(req);
157
158 return ret;
159}
160
161/*
162 * start_done - Handle START STOP UNIT return status
163 * @sdev: sdev the command has been sent to
164 * @errors: blk error code
165 */
166static int start_done(struct scsi_device *sdev, unsigned char *sense)
167{
168 struct scsi_sense_hdr sshdr;
169 int rc;
170
171 rc = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr);
172 if (!rc) {
173 sdev_printk(KERN_WARNING, sdev,
174 "%s: sending start_stop_unit failed, "
175 "no sense available\n",
176 HP_SW_NAME);
177 return SCSI_DH_IO;
178 }
179 switch (sshdr.sense_key) {
180 case NOT_READY:
181 if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) {
182 /*
183 * LUN not ready - manual intervention required
184 *
185 * Switch-over in progress, retry.
186 */
187 rc = SCSI_DH_RETRY;
188 break;
189 }
190 /* fall through */
191 default:
192 sdev_printk(KERN_WARNING, sdev,
193 "%s: sending start_stop_unit failed, sense %x/%x/%x\n",
194 HP_SW_NAME, sshdr.sense_key, sshdr.asc,
195 sshdr.ascq);
196 rc = SCSI_DH_IO;
197 }
198
199 return rc;
200}
201
202static void start_stop_endio(struct request *req, int error)
203{
204 struct hp_sw_dh_data *h = req->end_io_data;
205 unsigned err = SCSI_DH_OK;
206
207 if (error || host_byte(req->errors) != DID_OK ||
208 msg_byte(req->errors) != COMMAND_COMPLETE) {
209 sdev_printk(KERN_WARNING, h->sdev,
210 "%s: sending start_stop_unit failed with %x\n",
211 HP_SW_NAME, req->errors);
212 err = SCSI_DH_IO;
213 goto done;
214 }
215
216 if (req->sense_len > 0) {
217 err = start_done(h->sdev, h->sense);
218 if (err == SCSI_DH_RETRY) {
219 err = SCSI_DH_IO;
220 if (--h->retry_cnt) {
221 blk_put_request(req);
222 err = hp_sw_start_stop(h);
223 if (err == SCSI_DH_OK)
224 return;
225 }
226 }
227 }
228done:
229 req->end_io_data = NULL;
230 __blk_put_request(req->q, req);
231 if (h->callback_fn) {
232 h->callback_fn(h->callback_data, err);
233 h->callback_fn = h->callback_data = NULL;
234 }
235 return;
236
237}
238
239/*
240 * hp_sw_start_stop - Send START STOP UNIT command
241 * @sdev: sdev command should be sent to
242 *
243 * Sending START STOP UNIT activates the SP.
244 */
245static int hp_sw_start_stop(struct hp_sw_dh_data *h)
246{
247 struct request *req;
248
249 req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
250 if (!req)
251 return SCSI_DH_RES_TEMP_UNAVAIL;
252
253 req->cmd_type = REQ_TYPE_BLOCK_PC;
254 req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
255 REQ_FAILFAST_DRIVER;
256 req->cmd_len = COMMAND_SIZE(START_STOP);
257 req->cmd[0] = START_STOP;
258 req->cmd[4] = 1; /* Start spin cycle */
259 req->timeout = HP_SW_TIMEOUT;
260 req->sense = h->sense;
261 memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
262 req->sense_len = 0;
263 req->end_io_data = h;
264
265 blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
266 return SCSI_DH_OK;
267}
268
269static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
270{
271 struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
272 int ret = BLKPREP_OK;
273
274 if (h->path_state != HP_SW_PATH_ACTIVE) {
275 ret = BLKPREP_KILL;
276 req->cmd_flags |= REQ_QUIET;
277 }
278 return ret;
279
280}
281
282/*
283 * hp_sw_activate - Activate a path
284 * @sdev: sdev on the path to be activated
285 *
286 * The HP Active/Passive firmware is pretty simple;
287 * the passive path reports NOT READY with sense codes
288 * 0x04/0x02; a START STOP UNIT command will then
289 * activate the passive path (and deactivate the
290 * previously active one).
291 */
292static int hp_sw_activate(struct scsi_device *sdev,
293 activate_complete fn, void *data)
294{
295 int ret = SCSI_DH_OK;
296 struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
297
298 ret = hp_sw_tur(sdev, h);
299
300 if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
301 h->retry_cnt = h->retries;
302 h->callback_fn = fn;
303 h->callback_data = data;
304 ret = hp_sw_start_stop(h);
305 if (ret == SCSI_DH_OK)
306 return 0;
307 h->callback_fn = h->callback_data = NULL;
308 }
309
310 if (fn)
311 fn(data, ret);
312 return 0;
313}
314
315static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
316 {"COMPAQ", "MSA1000 VOLUME"},
317 {"COMPAQ", "HSV110"},
318 {"HP", "HSV100"},
319 {"DEC", "HSG80"},
320 {NULL, NULL},
321};
322
323static bool hp_sw_match(struct scsi_device *sdev)
324{
325 int i;
326
327 if (scsi_device_tpgs(sdev))
328 return false;
329
330 for (i = 0; hp_sw_dh_data_list[i].vendor; i++) {
331 if (!strncmp(sdev->vendor, hp_sw_dh_data_list[i].vendor,
332 strlen(hp_sw_dh_data_list[i].vendor)) &&
333 !strncmp(sdev->model, hp_sw_dh_data_list[i].model,
334 strlen(hp_sw_dh_data_list[i].model))) {
335 return true;
336 }
337 }
338 return false;
339}
340
341static int hp_sw_bus_attach(struct scsi_device *sdev);
342static void hp_sw_bus_detach(struct scsi_device *sdev);
343
344static struct scsi_device_handler hp_sw_dh = {
345 .name = HP_SW_NAME,
346 .module = THIS_MODULE,
347 .devlist = hp_sw_dh_data_list,
348 .attach = hp_sw_bus_attach,
349 .detach = hp_sw_bus_detach,
350 .activate = hp_sw_activate,
351 .prep_fn = hp_sw_prep_fn,
352 .match = hp_sw_match,
353};
354
355static int hp_sw_bus_attach(struct scsi_device *sdev)
356{
357 struct scsi_dh_data *scsi_dh_data;
358 struct hp_sw_dh_data *h;
359 unsigned long flags;
360 int ret;
361
362 scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
363 + sizeof(*h) , GFP_KERNEL);
364 if (!scsi_dh_data) {
365 sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
366 HP_SW_NAME);
367 return 0;
368 }
369
370 scsi_dh_data->scsi_dh = &hp_sw_dh;
371 h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
372 h->path_state = HP_SW_PATH_UNINITIALIZED;
373 h->retries = HP_SW_RETRIES;
374 h->sdev = sdev;
375
376 ret = hp_sw_tur(sdev, h);
377 if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
378 goto failed;
379
380 if (!try_module_get(THIS_MODULE))
381 goto failed;
382
383 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
384 sdev->scsi_dh_data = scsi_dh_data;
385 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
386
387 sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
388 HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
389 "active":"passive");
390
391 return 0;
392
393failed:
394 kfree(scsi_dh_data);
395 sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
396 HP_SW_NAME);
397 return -EINVAL;
398}
399
400static void hp_sw_bus_detach( struct scsi_device *sdev )
401{
402 struct scsi_dh_data *scsi_dh_data;
403 unsigned long flags;
404
405 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
406 scsi_dh_data = sdev->scsi_dh_data;
407 sdev->scsi_dh_data = NULL;
408 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
409 module_put(THIS_MODULE);
410
411 sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", HP_SW_NAME);
412
413 kfree(scsi_dh_data);
414}
415
416static int __init hp_sw_init(void)
417{
418 return scsi_register_device_handler(&hp_sw_dh);
419}
420
421static void __exit hp_sw_exit(void)
422{
423 scsi_unregister_device_handler(&hp_sw_dh);
424}
425
426module_init(hp_sw_init);
427module_exit(hp_sw_exit);
428
429MODULE_DESCRIPTION("HP Active/Passive driver");
430MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu");
431MODULE_LICENSE("GPL");