1 /*
2  * Target driver for EMC CLARiiON AX/CX-series hardware.
3  * Based on code from Lars Marowsky-Bree <lmb@suse.de>
4  * and Ed Goggin <egoggin@emc.com>.
5  *
6  * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
7  * Copyright (C) 2006 Mike Christie
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 #include <linux/slab.h>
24 #include <scsi/scsi.h>
25 #include <scsi/scsi_eh.h>
26 #include <scsi/scsi_dh.h>
27 #include <scsi/scsi_device.h>
28 
29 #define CLARIION_NAME			"emc"
30 
31 #define CLARIION_TRESPASS_PAGE		0x22
32 #define CLARIION_BUFFER_SIZE		0xFC
33 #define CLARIION_TIMEOUT		(60 * HZ)
34 #define CLARIION_RETRIES		3
35 #define CLARIION_UNBOUND_LU		-1
36 #define CLARIION_SP_A			0
37 #define CLARIION_SP_B			1
38 
39 /* Flags */
40 #define CLARIION_SHORT_TRESPASS		1
41 #define CLARIION_HONOR_RESERVATIONS	2
42 
43 /* LUN states */
44 #define CLARIION_LUN_UNINITIALIZED	-1
45 #define CLARIION_LUN_UNBOUND		0
46 #define CLARIION_LUN_BOUND		1
47 #define CLARIION_LUN_OWNED		2
48 
49 static unsigned char long_trespass[] = {
50 	0, 0, 0, 0, 0, 0, 0, 0,
51 	CLARIION_TRESPASS_PAGE,	/* Page code */
52 	0x09,			/* Page length - 2 */
53 	0x01,			/* Trespass code */
54 	0xff, 0xff,		/* Trespass target */
55 	0, 0, 0, 0, 0, 0	/* Reserved bytes / unknown */
56 };
57 
58 static unsigned char short_trespass[] = {
59 	0, 0, 0, 0,
60 	CLARIION_TRESPASS_PAGE,	/* Page code */
61 	0x02,			/* Page length - 2 */
62 	0x01,			/* Trespass code */
63 	0xff,			/* Trespass target */
64 };
65 
66 static const char * lun_state[] =
67 {
68     "not bound",
69     "bound",
70     "owned",
71 };
72 
73 struct clariion_dh_data {
74 	/*
75 	 * Flags:
76 	 *  CLARIION_SHORT_TRESPASS
77 	 * Use short trespass command (FC-series) or the long version
78 	 * (default for AX/CX CLARiiON arrays).
79 	 *
80 	 *  CLARIION_HONOR_RESERVATIONS
81 	 * Whether or not (default) to honor SCSI reservations when
82 	 * initiating a switch-over.
83 	 */
84 	unsigned flags;
85 	/*
86 	 * I/O buffer for both MODE_SELECT and INQUIRY commands.
87 	 */
88 	unsigned char buffer[CLARIION_BUFFER_SIZE];
89 	/*
90 	 * SCSI sense buffer for commands -- assumes serial issuance
91 	 * and completion sequence of all commands for same multipath.
92 	 */
93 	unsigned char sense[SCSI_SENSE_BUFFERSIZE];
94 	unsigned int senselen;
95 	/*
96 	 * LUN state
97 	 */
98 	int lun_state;
99 	/*
100 	 * SP Port number
101 	 */
102 	int port;
103 	/*
104 	 * which SP (A=0,B=1,UNBOUND=-1) is the default SP for this
105 	 * path's mapped LUN
106 	 */
107 	int default_sp;
108 	/*
109 	 * which SP (A=0,B=1,UNBOUND=-1) is the active SP for this
110 	 * path's mapped LUN
111 	 */
112 	int current_sp;
113 };
114 
115 static inline struct clariion_dh_data
116 			*get_clariion_data(struct scsi_device *sdev)
117 {
118 	struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
119 	BUG_ON(scsi_dh_data == NULL);
120 	return ((struct clariion_dh_data *) scsi_dh_data->buf);
121 }
122 
123 /*
124  * Parse MODE_SELECT cmd reply.
125  */
126 static int trespass_endio(struct scsi_device *sdev, char *sense)
127 {
128 	int err = SCSI_DH_IO;
129 	struct scsi_sense_hdr sshdr;
130 
131 	if (!scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)) {
132 		sdev_printk(KERN_ERR, sdev, "%s: Found valid sense data 0x%2x, "
133 			    "0x%2x, 0x%2x while sending CLARiiON trespass "
134 			    "command.\n", CLARIION_NAME, sshdr.sense_key,
135 			    sshdr.asc, sshdr.ascq);
136 
137 		if ((sshdr.sense_key == 0x05) && (sshdr.asc == 0x04) &&
138 		     (sshdr.ascq == 0x00)) {
139 			/*
140 			 * Array based copy in progress -- do not send
141 			 * mode_select or copy will be aborted mid-stream.
142 			 */
143 			sdev_printk(KERN_INFO, sdev, "%s: Array Based Copy in "
144 				    "progress while sending CLARiiON trespass "
145 				    "command.\n", CLARIION_NAME);
146 			err = SCSI_DH_DEV_TEMP_BUSY;
147 		} else if ((sshdr.sense_key == 0x02) && (sshdr.asc == 0x04) &&
148 			    (sshdr.ascq == 0x03)) {
149 			/*
150 			 * LUN Not Ready - Manual Intervention Required
151 			 * indicates in-progress ucode upgrade (NDU).
152 			 */
153 			sdev_printk(KERN_INFO, sdev, "%s: Detected in-progress "
154 				    "ucode upgrade NDU operation while sending "
155 				    "CLARiiON trespass command.\n", CLARIION_NAME);
156 			err = SCSI_DH_DEV_TEMP_BUSY;
157 		} else
158 			err = SCSI_DH_DEV_FAILED;
159 	} else {
160 		sdev_printk(KERN_INFO, sdev,
161 			    "%s: failed to send MODE SELECT, no sense available\n",
162 			    CLARIION_NAME);
163 	}
164 	return err;
165 }
166 
167 static int parse_sp_info_reply(struct scsi_device *sdev,
168 			       struct clariion_dh_data *csdev)
169 {
170 	int err = SCSI_DH_OK;
171 
172 	/* check for in-progress ucode upgrade (NDU) */
173 	if (csdev->buffer[48] != 0) {
174 		sdev_printk(KERN_NOTICE, sdev, "%s: Detected in-progress "
175 			    "ucode upgrade NDU operation while finding "
176 			    "current active SP.", CLARIION_NAME);
177 		err = SCSI_DH_DEV_TEMP_BUSY;
178 		goto out;
179 	}
180 	if (csdev->buffer[4] > 2) {
181 		/* Invalid buffer format */
182 		sdev_printk(KERN_NOTICE, sdev,
183 			    "%s: invalid VPD page 0xC0 format\n",
184 			    CLARIION_NAME);
185 		err = SCSI_DH_NOSYS;
186 		goto out;
187 	}
188 	switch (csdev->buffer[28] & 0x0f) {
189 	case 6:
190 		sdev_printk(KERN_NOTICE, sdev,
191 			    "%s: ALUA failover mode detected\n",
192 			    CLARIION_NAME);
193 		break;
194 	case 4:
195 		/* Linux failover */
196 		break;
197 	default:
198 		sdev_printk(KERN_WARNING, sdev,
199 			    "%s: Invalid failover mode %d\n",
200 			    CLARIION_NAME, csdev->buffer[28] & 0x0f);
201 		err = SCSI_DH_NOSYS;
202 		goto out;
203 	}
204 
205 	csdev->default_sp = csdev->buffer[5];
206 	csdev->lun_state = csdev->buffer[4];
207 	csdev->current_sp = csdev->buffer[8];
208 	csdev->port = csdev->buffer[7];
209 
210 out:
211 	return err;
212 }
213 
214 #define emc_default_str "FC (Legacy)"
215 
216 static char * parse_sp_model(struct scsi_device *sdev, unsigned char *buffer)
217 {
218 	unsigned char len = buffer[4] + 5;
219 	char *sp_model = NULL;
220 	unsigned char sp_len, serial_len;
221 
222 	if (len < 160) {
223 		sdev_printk(KERN_WARNING, sdev,
224 			    "%s: Invalid information section length %d\n",
225 			    CLARIION_NAME, len);
226 		/* Check for old FC arrays */
227 		if (!strncmp(buffer + 8, "DGC", 3)) {
228 			/* Old FC array, not supporting extended information */
229 			sp_model = emc_default_str;
230 		}
231 		goto out;
232 	}
233 
234 	/*
235 	 * Parse extended information for SP model number
236 	 */
237 	serial_len = buffer[160];
238 	if (serial_len == 0 || serial_len + 161 > len) {
239 		sdev_printk(KERN_WARNING, sdev,
240 			    "%s: Invalid array serial number length %d\n",
241 			    CLARIION_NAME, serial_len);
242 		goto out;
243 	}
244 	sp_len = buffer[99];
245 	if (sp_len == 0 || serial_len + sp_len + 161 > len) {
246 		sdev_printk(KERN_WARNING, sdev,
247 			    "%s: Invalid model number length %d\n",
248 			    CLARIION_NAME, sp_len);
249 		goto out;
250 	}
251 	sp_model = &buffer[serial_len + 161];
252 	/* Strip whitespace at the end */
253 	while (sp_len > 1 && sp_model[sp_len - 1] == ' ')
254 		sp_len--;
255 
256 	sp_model[sp_len] = '\0';
257 
258 out:
259 	return sp_model;
260 }
261 
262 /*
263  * Get block request for REQ_BLOCK_PC command issued to path.  Currently
264  * limited to MODE_SELECT (trespass) and INQUIRY (VPD page 0xC0) commands.
265  *
266  * Uses data and sense buffers in hardware handler context structure and
267  * assumes serial servicing of commands, both issuance and completion.
268  */
269 static struct request *get_req(struct scsi_device *sdev, int cmd,
270 				unsigned char *buffer)
271 {
272 	struct request *rq;
273 	int len = 0;
274 
275 	rq = blk_get_request(sdev->request_queue,
276 			(cmd != INQUIRY) ? WRITE : READ, GFP_NOIO);
277 	if (!rq) {
278 		sdev_printk(KERN_INFO, sdev, "get_req: blk_get_request failed");
279 		return NULL;
280 	}
281 
282 	rq->cmd_len = COMMAND_SIZE(cmd);
283 	rq->cmd[0] = cmd;
284 
285 	switch (cmd) {
286 	case MODE_SELECT:
287 		len = sizeof(short_trespass);
288 		rq->cmd[1] = 0x10;
289 		rq->cmd[4] = len;
290 		break;
291 	case MODE_SELECT_10:
292 		len = sizeof(long_trespass);
293 		rq->cmd[1] = 0x10;
294 		rq->cmd[8] = len;
295 		break;
296 	case INQUIRY:
297 		len = CLARIION_BUFFER_SIZE;
298 		rq->cmd[4] = len;
299 		memset(buffer, 0, len);
300 		break;
301 	default:
302 		BUG_ON(1);
303 		break;
304 	}
305 
306 	rq->cmd_type = REQ_TYPE_BLOCK_PC;
307 	rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
308 			 REQ_FAILFAST_DRIVER;
309 	rq->timeout = CLARIION_TIMEOUT;
310 	rq->retries = CLARIION_RETRIES;
311 
312 	if (blk_rq_map_kern(rq->q, rq, buffer, len, GFP_NOIO)) {
313 		blk_put_request(rq);
314 		return NULL;
315 	}
316 
317 	return rq;
318 }
319 
320 static int send_inquiry_cmd(struct scsi_device *sdev, int page,
321 			    struct clariion_dh_data *csdev)
322 {
323 	struct request *rq = get_req(sdev, INQUIRY, csdev->buffer);
324 	int err;
325 
326 	if (!rq)
327 		return SCSI_DH_RES_TEMP_UNAVAIL;
328 
329 	rq->sense = csdev->sense;
330 	memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
331 	rq->sense_len = csdev->senselen = 0;
332 
333 	rq->cmd[0] = INQUIRY;
334 	if (page != 0) {
335 		rq->cmd[1] = 1;
336 		rq->cmd[2] = page;
337 	}
338 	err = blk_execute_rq(sdev->request_queue, NULL, rq, 1);
339 	if (err == -EIO) {
340 		sdev_printk(KERN_INFO, sdev,
341 			    "%s: failed to send %s INQUIRY: %x\n",
342 			    CLARIION_NAME, page?"EVPD":"standard",
343 			    rq->errors);
344 		csdev->senselen = rq->sense_len;
345 		err = SCSI_DH_IO;
346 	}
347 
348 	blk_put_request(rq);
349 
350 	return err;
351 }
352 
353 static int send_trespass_cmd(struct scsi_device *sdev,
354 			    struct clariion_dh_data *csdev)
355 {
356 	struct request *rq;
357 	unsigned char *page22;
358 	int err, len, cmd;
359 
360 	if (csdev->flags & CLARIION_SHORT_TRESPASS) {
361 		page22 = short_trespass;
362 		if (!(csdev->flags & CLARIION_HONOR_RESERVATIONS))
363 			/* Set Honor Reservations bit */
364 			page22[6] |= 0x80;
365 		len = sizeof(short_trespass);
366 		cmd = MODE_SELECT;
367 	} else {
368 		page22 = long_trespass;
369 		if (!(csdev->flags & CLARIION_HONOR_RESERVATIONS))
370 			/* Set Honor Reservations bit */
371 			page22[10] |= 0x80;
372 		len = sizeof(long_trespass);
373 		cmd = MODE_SELECT_10;
374 	}
375 	BUG_ON((len > CLARIION_BUFFER_SIZE));
376 	memcpy(csdev->buffer, page22, len);
377 
378 	rq = get_req(sdev, cmd, csdev->buffer);
379 	if (!rq)
380 		return SCSI_DH_RES_TEMP_UNAVAIL;
381 
382 	rq->sense = csdev->sense;
383 	memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
384 	rq->sense_len = csdev->senselen = 0;
385 
386 	err = blk_execute_rq(sdev->request_queue, NULL, rq, 1);
387 	if (err == -EIO) {
388 		if (rq->sense_len) {
389 			err = trespass_endio(sdev, csdev->sense);
390 		} else {
391 			sdev_printk(KERN_INFO, sdev,
392 				    "%s: failed to send MODE SELECT: %x\n",
393 				    CLARIION_NAME, rq->errors);
394 		}
395 	}
396 
397 	blk_put_request(rq);
398 
399 	return err;
400 }
401 
402 static int clariion_check_sense(struct scsi_device *sdev,
403 				struct scsi_sense_hdr *sense_hdr)
404 {
405 	switch (sense_hdr->sense_key) {
406 	case NOT_READY:
407 		if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x03)
408 			/*
409 			 * LUN Not Ready - Manual Intervention Required
410 			 * indicates this is a passive path.
411 			 *
412 			 * FIXME: However, if this is seen and EVPD C0
413 			 * indicates that this is due to a NDU in
414 			 * progress, we should set FAIL_PATH too.
415 			 * This indicates we might have to do a SCSI
416 			 * inquiry in the end_io path. Ugh.
417 			 *
418 			 * Can return FAILED only when we want the error
419 			 * recovery process to kick in.
420 			 */
421 			return SUCCESS;
422 		break;
423 	case ILLEGAL_REQUEST:
424 		if (sense_hdr->asc == 0x25 && sense_hdr->ascq == 0x01)
425 			/*
426 			 * An array based copy is in progress. Do not
427 			 * fail the path, do not bypass to another PG,
428 			 * do not retry. Fail the IO immediately.
429 			 * (Actually this is the same conclusion as in
430 			 * the default handler, but lets make sure.)
431 			 *
432 			 * Can return FAILED only when we want the error
433 			 * recovery process to kick in.
434 			 */
435 			return SUCCESS;
436 		break;
437 	case UNIT_ATTENTION:
438 		if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
439 			/*
440 			 * Unit Attention Code. This is the first IO
441 			 * to the new path, so just retry.
442 			 */
443 			return ADD_TO_MLQUEUE;
444 		break;
445 	}
446 
447 	return SCSI_RETURN_NOT_HANDLED;
448 }
449 
450 static int clariion_prep_fn(struct scsi_device *sdev, struct request *req)
451 {
452 	struct clariion_dh_data *h = get_clariion_data(sdev);
453 	int ret = BLKPREP_OK;
454 
455 	if (h->lun_state != CLARIION_LUN_OWNED) {
456 		ret = BLKPREP_KILL;
457 		req->cmd_flags |= REQ_QUIET;
458 	}
459 	return ret;
460 
461 }
462 
463 static int clariion_std_inquiry(struct scsi_device *sdev,
464 				struct clariion_dh_data *csdev)
465 {
466 	int err;
467 	char *sp_model;
468 
469 	err = send_inquiry_cmd(sdev, 0, csdev);
470 	if (err != SCSI_DH_OK && csdev->senselen) {
471 		struct scsi_sense_hdr sshdr;
472 
473 		if (scsi_normalize_sense(csdev->sense, SCSI_SENSE_BUFFERSIZE,
474 					 &sshdr)) {
475 			sdev_printk(KERN_ERR, sdev, "%s: INQUIRY sense code "
476 				    "%02x/%02x/%02x\n", CLARIION_NAME,
477 				    sshdr.sense_key, sshdr.asc, sshdr.ascq);
478 		}
479 		err = SCSI_DH_IO;
480 		goto out;
481 	}
482 
483 	sp_model = parse_sp_model(sdev, csdev->buffer);
484 	if (!sp_model) {
485 		err = SCSI_DH_DEV_UNSUPP;
486 		goto out;
487 	}
488 
489 	/*
490 	 * FC Series arrays do not support long trespass
491 	 */
492 	if (!strlen(sp_model) || !strncmp(sp_model, "FC",2))
493 		csdev->flags |= CLARIION_SHORT_TRESPASS;
494 
495 	sdev_printk(KERN_INFO, sdev,
496 		    "%s: detected Clariion %s, flags %x\n",
497 		    CLARIION_NAME, sp_model, csdev->flags);
498 out:
499 	return err;
500 }
501 
502 static int clariion_send_inquiry(struct scsi_device *sdev,
503 				 struct clariion_dh_data *csdev)
504 {
505 	int err, retry = CLARIION_RETRIES;
506 
507 retry:
508 	err = send_inquiry_cmd(sdev, 0xC0, csdev);
509 	if (err != SCSI_DH_OK && csdev->senselen) {
510 		struct scsi_sense_hdr sshdr;
511 
512 		err = scsi_normalize_sense(csdev->sense, SCSI_SENSE_BUFFERSIZE,
513 					   &sshdr);
514 		if (!err)
515 			return SCSI_DH_IO;
516 
517 		err = clariion_check_sense(sdev, &sshdr);
518 		if (retry > 0 && err == ADD_TO_MLQUEUE) {
519 			retry--;
520 			goto retry;
521 		}
522 		sdev_printk(KERN_ERR, sdev, "%s: INQUIRY sense code "
523 			    "%02x/%02x/%02x\n", CLARIION_NAME,
524 			      sshdr.sense_key, sshdr.asc, sshdr.ascq);
525 		err = SCSI_DH_IO;
526 	} else {
527 		err = parse_sp_info_reply(sdev, csdev);
528 	}
529 	return err;
530 }
531 
532 static int clariion_activate(struct scsi_device *sdev,
533 				activate_complete fn, void *data)
534 {
535 	struct clariion_dh_data *csdev = get_clariion_data(sdev);
536 	int result;
537 
538 	result = clariion_send_inquiry(sdev, csdev);
539 	if (result != SCSI_DH_OK)
540 		goto done;
541 
542 	if (csdev->lun_state == CLARIION_LUN_OWNED)
543 		goto done;
544 
545 	result = send_trespass_cmd(sdev, csdev);
546 	if (result != SCSI_DH_OK)
547 		goto done;
548 	sdev_printk(KERN_INFO, sdev,"%s: %s trespass command sent\n",
549 		    CLARIION_NAME,
550 		    csdev->flags&CLARIION_SHORT_TRESPASS?"short":"long" );
551 
552 	/* Update status */
553 	result = clariion_send_inquiry(sdev, csdev);
554 	if (result != SCSI_DH_OK)
555 		goto done;
556 
557 done:
558 	sdev_printk(KERN_INFO, sdev,
559 		    "%s: at SP %c Port %d (%s, default SP %c)\n",
560 		    CLARIION_NAME, csdev->current_sp + 'A',
561 		    csdev->port, lun_state[csdev->lun_state],
562 		    csdev->default_sp + 'A');
563 
564 	if (fn)
565 		fn(data, result);
566 	return 0;
567 }
568 /*
569  * params - parameters in the following format
570  *      "no_of_params\0param1\0param2\0param3\0...\0"
571  *      for example, string for 2 parameters with value 10 and 21
572  *      is specified as "2\010\021\0".
573  */
574 static int clariion_set_params(struct scsi_device *sdev, const char *params)
575 {
576 	struct clariion_dh_data *csdev = get_clariion_data(sdev);
577 	unsigned int hr = 0, st = 0, argc;
578 	const char *p = params;
579 	int result = SCSI_DH_OK;
580 
581 	if ((sscanf(params, "%u", &argc) != 1) || (argc != 2))
582 		return -EINVAL;
583 
584 	while (*p++)
585 		;
586 	if ((sscanf(p, "%u", &st) != 1) || (st > 1))
587 		return -EINVAL;
588 
589 	while (*p++)
590 		;
591 	if ((sscanf(p, "%u", &hr) != 1) || (hr > 1))
592 		return -EINVAL;
593 
594 	if (st)
595 		csdev->flags |= CLARIION_SHORT_TRESPASS;
596 	else
597 		csdev->flags &= ~CLARIION_SHORT_TRESPASS;
598 
599 	if (hr)
600 		csdev->flags |= CLARIION_HONOR_RESERVATIONS;
601 	else
602 		csdev->flags &= ~CLARIION_HONOR_RESERVATIONS;
603 
604 	/*
605 	 * If this path is owned, we have to send a trespass command
606 	 * with the new parameters. If not, simply return. Next trespass
607 	 * command would use the parameters.
608 	 */
609 	if (csdev->lun_state != CLARIION_LUN_OWNED)
610 		goto done;
611 
612 	csdev->lun_state = CLARIION_LUN_UNINITIALIZED;
613 	result = send_trespass_cmd(sdev, csdev);
614 	if (result != SCSI_DH_OK)
615 		goto done;
616 
617 	/* Update status */
618 	result = clariion_send_inquiry(sdev, csdev);
619 
620 done:
621 	return result;
622 }
623 
624 static const struct scsi_dh_devlist clariion_dev_list[] = {
625 	{"DGC", "RAID"},
626 	{"DGC", "DISK"},
627 	{"DGC", "VRAID"},
628 	{NULL, NULL},
629 };
630 
631 static int clariion_bus_attach(struct scsi_device *sdev);
632 static void clariion_bus_detach(struct scsi_device *sdev);
633 
634 static struct scsi_device_handler clariion_dh = {
635 	.name		= CLARIION_NAME,
636 	.module		= THIS_MODULE,
637 	.devlist	= clariion_dev_list,
638 	.attach		= clariion_bus_attach,
639 	.detach		= clariion_bus_detach,
640 	.check_sense	= clariion_check_sense,
641 	.activate	= clariion_activate,
642 	.prep_fn	= clariion_prep_fn,
643 	.set_params	= clariion_set_params,
644 };
645 
646 static int clariion_bus_attach(struct scsi_device *sdev)
647 {
648 	struct scsi_dh_data *scsi_dh_data;
649 	struct clariion_dh_data *h;
650 	unsigned long flags;
651 	int err;
652 
653 	scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
654 			       + sizeof(*h) , GFP_KERNEL);
655 	if (!scsi_dh_data) {
656 		sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
657 			    CLARIION_NAME);
658 		return -ENOMEM;
659 	}
660 
661 	scsi_dh_data->scsi_dh = &clariion_dh;
662 	h = (struct clariion_dh_data *) scsi_dh_data->buf;
663 	h->lun_state = CLARIION_LUN_UNINITIALIZED;
664 	h->default_sp = CLARIION_UNBOUND_LU;
665 	h->current_sp = CLARIION_UNBOUND_LU;
666 
667 	err = clariion_std_inquiry(sdev, h);
668 	if (err != SCSI_DH_OK)
669 		goto failed;
670 
671 	err = clariion_send_inquiry(sdev, h);
672 	if (err != SCSI_DH_OK)
673 		goto failed;
674 
675 	if (!try_module_get(THIS_MODULE))
676 		goto failed;
677 
678 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
679 	sdev->scsi_dh_data = scsi_dh_data;
680 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
681 
682 	sdev_printk(KERN_INFO, sdev,
683 		    "%s: connected to SP %c Port %d (%s, default SP %c)\n",
684 		    CLARIION_NAME, h->current_sp + 'A',
685 		    h->port, lun_state[h->lun_state],
686 		    h->default_sp + 'A');
687 
688 	return 0;
689 
690 failed:
691 	kfree(scsi_dh_data);
692 	sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
693 		    CLARIION_NAME);
694 	return -EINVAL;
695 }
696 
697 static void clariion_bus_detach(struct scsi_device *sdev)
698 {
699 	struct scsi_dh_data *scsi_dh_data;
700 	unsigned long flags;
701 
702 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
703 	scsi_dh_data = sdev->scsi_dh_data;
704 	sdev->scsi_dh_data = NULL;
705 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
706 
707 	sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n",
708 		    CLARIION_NAME);
709 
710 	kfree(scsi_dh_data);
711 	module_put(THIS_MODULE);
712 }
713 
714 static int __init clariion_init(void)
715 {
716 	int r;
717 
718 	r = scsi_register_device_handler(&clariion_dh);
719 	if (r != 0)
720 		printk(KERN_ERR "%s: Failed to register scsi device handler.",
721 			CLARIION_NAME);
722 	return r;
723 }
724 
725 static void __exit clariion_exit(void)
726 {
727 	scsi_unregister_device_handler(&clariion_dh);
728 }
729 
730 module_init(clariion_init);
731 module_exit(clariion_exit);
732 
733 MODULE_DESCRIPTION("EMC CX/AX/FC-family driver");
734 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, Chandra Seetharaman <sekharan@us.ibm.com>");
735 MODULE_LICENSE("GPL");
736