Commit | Line | Data |
---|---|---|
5e7dccad CS |
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 | */ | |
5a0e3ad6 | 23 | #include <linux/slab.h> |
5e7dccad CS |
24 | #include <scsi/scsi.h> |
25 | #include <scsi/scsi_eh.h> | |
26 | #include <scsi/scsi_dh.h> | |
27 | #include <scsi/scsi_device.h> | |
28 | ||
b6ff1b14 | 29 | #define CLARIION_NAME "emc" |
5e7dccad CS |
30 | |
31 | #define CLARIION_TRESPASS_PAGE 0x22 | |
b6ff1b14 | 32 | #define CLARIION_BUFFER_SIZE 0xFC |
5e7dccad CS |
33 | #define CLARIION_TIMEOUT (60 * HZ) |
34 | #define CLARIION_RETRIES 3 | |
35 | #define CLARIION_UNBOUND_LU -1 | |
b6ff1b14 HR |
36 | #define CLARIION_SP_A 0 |
37 | #define CLARIION_SP_B 1 | |
5e7dccad | 38 | |
b6ff1b14 HR |
39 | /* Flags */ |
40 | #define CLARIION_SHORT_TRESPASS 1 | |
41 | #define CLARIION_HONOR_RESERVATIONS 2 | |
5e7dccad | 42 | |
b6ff1b14 HR |
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, | |
5e7dccad CS |
51 | CLARIION_TRESPASS_PAGE, /* Page code */ |
52 | 0x09, /* Page length - 2 */ | |
b6ff1b14 | 53 | 0x01, /* Trespass code */ |
5e7dccad CS |
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 */ | |
b6ff1b14 | 62 | 0x01, /* Trespass code */ |
5e7dccad CS |
63 | 0xff, /* Trespass target */ |
64 | }; | |
65 | ||
b6ff1b14 HR |
66 | static const char * lun_state[] = |
67 | { | |
68 | "not bound", | |
69 | "bound", | |
70 | "owned", | |
5e7dccad CS |
71 | }; |
72 | ||
73 | struct clariion_dh_data { | |
74 | /* | |
b6ff1b14 HR |
75 | * Flags: |
76 | * CLARIION_SHORT_TRESPASS | |
5e7dccad CS |
77 | * Use short trespass command (FC-series) or the long version |
78 | * (default for AX/CX CLARiiON arrays). | |
b6ff1b14 HR |
79 | * |
80 | * CLARIION_HONOR_RESERVATIONS | |
5e7dccad CS |
81 | * Whether or not (default) to honor SCSI reservations when |
82 | * initiating a switch-over. | |
83 | */ | |
b6ff1b14 HR |
84 | unsigned flags; |
85 | /* | |
86 | * I/O buffer for both MODE_SELECT and INQUIRY commands. | |
87 | */ | |
7ae628d9 | 88 | unsigned char buffer[CLARIION_BUFFER_SIZE]; |
5e7dccad CS |
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]; | |
b6ff1b14 HR |
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 | */ | |
5e7dccad | 107 | int default_sp; |
b6ff1b14 HR |
108 | /* |
109 | * which SP (A=0,B=1,UNBOUND=-1) is the active SP for this | |
110 | * path's mapped LUN | |
111 | */ | |
5e7dccad CS |
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 | */ | |
b6ff1b14 | 126 | static int trespass_endio(struct scsi_device *sdev, char *sense) |
5e7dccad | 127 | { |
b6ff1b14 | 128 | int err = SCSI_DH_IO; |
5e7dccad | 129 | struct scsi_sense_hdr sshdr; |
5e7dccad | 130 | |
b6ff1b14 HR |
131 | if (!scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)) { |
132 | sdev_printk(KERN_ERR, sdev, "%s: Found valid sense data 0x%2x, " | |
5e7dccad | 133 | "0x%2x, 0x%2x while sending CLARiiON trespass " |
b6ff1b14 HR |
134 | "command.\n", CLARIION_NAME, sshdr.sense_key, |
135 | sshdr.asc, sshdr.ascq); | |
5e7dccad CS |
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 | */ | |
b6ff1b14 | 143 | sdev_printk(KERN_INFO, sdev, "%s: Array Based Copy in " |
5e7dccad | 144 | "progress while sending CLARiiON trespass " |
b6ff1b14 | 145 | "command.\n", CLARIION_NAME); |
5e7dccad CS |
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 | */ | |
b6ff1b14 | 153 | sdev_printk(KERN_INFO, sdev, "%s: Detected in-progress " |
5e7dccad | 154 | "ucode upgrade NDU operation while sending " |
b6ff1b14 | 155 | "CLARiiON trespass command.\n", CLARIION_NAME); |
5e7dccad CS |
156 | err = SCSI_DH_DEV_TEMP_BUSY; |
157 | } else | |
158 | err = SCSI_DH_DEV_FAILED; | |
b6ff1b14 HR |
159 | } else { |
160 | sdev_printk(KERN_INFO, sdev, | |
161 | "%s: failed to send MODE SELECT, no sense available\n", | |
162 | CLARIION_NAME); | |
5e7dccad | 163 | } |
5e7dccad CS |
164 | return err; |
165 | } | |
166 | ||
b6ff1b14 HR |
167 | static int parse_sp_info_reply(struct scsi_device *sdev, |
168 | struct clariion_dh_data *csdev) | |
5e7dccad CS |
169 | { |
170 | int err = SCSI_DH_OK; | |
5e7dccad | 171 | |
b6ff1b14 HR |
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 | } | |
7ae628d9 | 180 | if (csdev->buffer[4] > 2) { |
b6ff1b14 HR |
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; | |
5e7dccad CS |
203 | } |
204 | ||
b6ff1b14 HR |
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: | |
5e7dccad CS |
211 | return err; |
212 | } | |
213 | ||
b6ff1b14 HR |
214 | #define emc_default_str "FC (Legacy)" |
215 | ||
216 | static char * parse_sp_model(struct scsi_device *sdev, unsigned char *buffer) | |
5e7dccad | 217 | { |
b6ff1b14 HR |
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 | } | |
5e7dccad | 233 | |
b6ff1b14 HR |
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--; | |
5e7dccad | 255 | |
b6ff1b14 | 256 | sp_model[sp_len] = '\0'; |
5e7dccad | 257 | |
b6ff1b14 HR |
258 | out: |
259 | return sp_model; | |
5e7dccad CS |
260 | } |
261 | ||
262 | /* | |
765cbc6d HR |
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 | */ | |
b6ff1b14 HR |
269 | static struct request *get_req(struct scsi_device *sdev, int cmd, |
270 | unsigned char *buffer) | |
5e7dccad | 271 | { |
5e7dccad | 272 | struct request *rq; |
5e7dccad CS |
273 | int len = 0; |
274 | ||
275 | rq = blk_get_request(sdev->request_queue, | |
6c71dcb2 | 276 | (cmd != INQUIRY) ? WRITE : READ, GFP_NOIO); |
5e7dccad CS |
277 | if (!rq) { |
278 | sdev_printk(KERN_INFO, sdev, "get_req: blk_get_request failed"); | |
279 | return NULL; | |
280 | } | |
281 | ||
b6ff1b14 | 282 | rq->cmd_len = COMMAND_SIZE(cmd); |
5e7dccad | 283 | rq->cmd[0] = cmd; |
5e7dccad CS |
284 | |
285 | switch (cmd) { | |
286 | case MODE_SELECT: | |
b6ff1b14 | 287 | len = sizeof(short_trespass); |
b6ff1b14 | 288 | rq->cmd[1] = 0x10; |
6c71dcb2 | 289 | rq->cmd[4] = len; |
b6ff1b14 HR |
290 | break; |
291 | case MODE_SELECT_10: | |
292 | len = sizeof(long_trespass); | |
5e7dccad | 293 | rq->cmd[1] = 0x10; |
6c71dcb2 | 294 | rq->cmd[8] = len; |
5e7dccad CS |
295 | break; |
296 | case INQUIRY: | |
5e7dccad | 297 | len = CLARIION_BUFFER_SIZE; |
6c71dcb2 | 298 | rq->cmd[4] = len; |
b6ff1b14 | 299 | memset(buffer, 0, len); |
5e7dccad CS |
300 | break; |
301 | default: | |
302 | BUG_ON(1); | |
303 | break; | |
304 | } | |
305 | ||
5e7dccad | 306 | rq->cmd_type = REQ_TYPE_BLOCK_PC; |
6000a368 MC |
307 | rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | |
308 | REQ_FAILFAST_DRIVER; | |
5e7dccad CS |
309 | rq->timeout = CLARIION_TIMEOUT; |
310 | rq->retries = CLARIION_RETRIES; | |
311 | ||
b6ff1b14 HR |
312 | if (blk_rq_map_kern(rq->q, rq, buffer, len, GFP_NOIO)) { |
313 | blk_put_request(rq); | |
5e7dccad CS |
314 | return NULL; |
315 | } | |
316 | ||
317 | return rq; | |
318 | } | |
319 | ||
b6ff1b14 HR |
320 | static int send_inquiry_cmd(struct scsi_device *sdev, int page, |
321 | struct clariion_dh_data *csdev) | |
5e7dccad | 322 | { |
b6ff1b14 HR |
323 | struct request *rq = get_req(sdev, INQUIRY, csdev->buffer); |
324 | int err; | |
5e7dccad CS |
325 | |
326 | if (!rq) | |
327 | return SCSI_DH_RES_TEMP_UNAVAIL; | |
328 | ||
b6ff1b14 HR |
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; | |
5e7dccad CS |
351 | } |
352 | ||
b6ff1b14 HR |
353 | static int send_trespass_cmd(struct scsi_device *sdev, |
354 | struct clariion_dh_data *csdev) | |
5e7dccad | 355 | { |
b6ff1b14 HR |
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); | |
5e7dccad | 377 | |
b6ff1b14 HR |
378 | rq = get_req(sdev, cmd, csdev->buffer); |
379 | if (!rq) | |
380 | return SCSI_DH_RES_TEMP_UNAVAIL; | |
5e7dccad | 381 | |
b6ff1b14 HR |
382 | rq->sense = csdev->sense; |
383 | memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE); | |
384 | rq->sense_len = csdev->senselen = 0; | |
5e7dccad | 385 | |
b6ff1b14 HR |
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; | |
5e7dccad CS |
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 | */ | |
c7dbb627 | 443 | return ADD_TO_MLQUEUE; |
5e7dccad CS |
444 | break; |
445 | } | |
446 | ||
b6ff1b14 HR |
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); | |
c7dbb627 | 518 | if (retry > 0 && err == ADD_TO_MLQUEUE) { |
b6ff1b14 HR |
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 | ||
3ae31f6a CS |
532 | static int clariion_activate(struct scsi_device *sdev, |
533 | activate_complete fn, void *data) | |
b6ff1b14 HR |
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 | ||
3ae31f6a CS |
564 | if (fn) |
565 | fn(data, result); | |
566 | return 0; | |
5e7dccad | 567 | } |
14d9cb5f CS |
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 | } | |
5e7dccad | 623 | |
f08c0761 | 624 | static const struct scsi_dh_devlist clariion_dev_list[] = { |
5e7dccad CS |
625 | {"DGC", "RAID"}, |
626 | {"DGC", "DISK"}, | |
b6ff1b14 | 627 | {"DGC", "VRAID"}, |
5e7dccad CS |
628 | {NULL, NULL}, |
629 | }; | |
630 | ||
765cbc6d HR |
631 | static int clariion_bus_attach(struct scsi_device *sdev); |
632 | static void clariion_bus_detach(struct scsi_device *sdev); | |
5e7dccad CS |
633 | |
634 | static struct scsi_device_handler clariion_dh = { | |
635 | .name = CLARIION_NAME, | |
636 | .module = THIS_MODULE, | |
765cbc6d HR |
637 | .devlist = clariion_dev_list, |
638 | .attach = clariion_bus_attach, | |
639 | .detach = clariion_bus_detach, | |
5e7dccad CS |
640 | .check_sense = clariion_check_sense, |
641 | .activate = clariion_activate, | |
b6ff1b14 | 642 | .prep_fn = clariion_prep_fn, |
14d9cb5f | 643 | .set_params = clariion_set_params, |
5e7dccad CS |
644 | }; |
645 | ||
765cbc6d | 646 | static int clariion_bus_attach(struct scsi_device *sdev) |
5e7dccad | 647 | { |
5e7dccad CS |
648 | struct scsi_dh_data *scsi_dh_data; |
649 | struct clariion_dh_data *h; | |
5e7dccad | 650 | unsigned long flags; |
b6ff1b14 | 651 | int err; |
5e7dccad | 652 | |
9dfeb315 | 653 | scsi_dh_data = kzalloc(sizeof(*scsi_dh_data) |
765cbc6d HR |
654 | + sizeof(*h) , GFP_KERNEL); |
655 | if (!scsi_dh_data) { | |
b6ff1b14 | 656 | sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n", |
765cbc6d HR |
657 | CLARIION_NAME); |
658 | return -ENOMEM; | |
659 | } | |
5e7dccad | 660 | |
765cbc6d HR |
661 | scsi_dh_data->scsi_dh = &clariion_dh; |
662 | h = (struct clariion_dh_data *) scsi_dh_data->buf; | |
b6ff1b14 | 663 | h->lun_state = CLARIION_LUN_UNINITIALIZED; |
765cbc6d HR |
664 | h->default_sp = CLARIION_UNBOUND_LU; |
665 | h->current_sp = CLARIION_UNBOUND_LU; | |
5e7dccad | 666 | |
b6ff1b14 HR |
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 | ||
765cbc6d HR |
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); | |
5e7dccad | 681 | |
b6ff1b14 HR |
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'); | |
5e7dccad | 687 | |
765cbc6d | 688 | return 0; |
b6ff1b14 HR |
689 | |
690 | failed: | |
691 | kfree(scsi_dh_data); | |
692 | sdev_printk(KERN_ERR, sdev, "%s: not attached\n", | |
693 | CLARIION_NAME); | |
694 | return -EINVAL; | |
765cbc6d | 695 | } |
5e7dccad | 696 | |
765cbc6d HR |
697 | static void clariion_bus_detach(struct scsi_device *sdev) |
698 | { | |
699 | struct scsi_dh_data *scsi_dh_data; | |
700 | unsigned long flags; | |
5e7dccad | 701 | |
765cbc6d HR |
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); | |
5e7dccad | 706 | |
b6ff1b14 | 707 | sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", |
765cbc6d | 708 | CLARIION_NAME); |
5e7dccad | 709 | |
765cbc6d HR |
710 | kfree(scsi_dh_data); |
711 | module_put(THIS_MODULE); | |
5e7dccad CS |
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) | |
b6ff1b14 HR |
720 | printk(KERN_ERR "%s: Failed to register scsi device handler.", |
721 | CLARIION_NAME); | |
5e7dccad CS |
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"); |