1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Enclosure Services Device target driver
23 *
24 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
27 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
28 */
29
30 #include <sys/modctl.h>
31 #include <sys/file.h>
32 #include <sys/scsi/scsi.h>
33 #include <sys/scsi/generic/status.h>
34 #include <sys/scsi/targets/sesio.h>
35 #include <sys/scsi/targets/ses.h>
36
37
38
39 /*
40 * Power management defines (should be in a common include file?)
41 */
42 #define PM_HARDWARE_STATE_PROP "pm-hardware-state"
43 #define PM_NEEDS_SUSPEND_RESUME "needs-suspend-resume"
44
45
46 /*
47 * Global Driver Data
48 */
49 int ses_io_time = SES_IO_TIME;
50
51 static int ses_retry_count = SES_RETRY_COUNT * SES_RETRY_MULTIPLIER;
52
53 #ifdef DEBUG
54 int ses_debug = 0;
55 #else /* DEBUG */
56 #define ses_debug 0
57 #endif /* DEBUG */
58
59
60 /*
61 * External Enclosure Functions
62 */
63 extern int ses_softc_init(ses_softc_t *, int);
64 extern int ses_init_enc(ses_softc_t *);
65 extern int ses_get_encstat(ses_softc_t *, int);
66 extern int ses_set_encstat(ses_softc_t *, uchar_t, int);
67 extern int ses_get_objstat(ses_softc_t *, ses_objarg *, int);
68 extern int ses_set_objstat(ses_softc_t *, ses_objarg *, int);
69
70 extern int safte_softc_init(ses_softc_t *, int);
71 extern int safte_init_enc(ses_softc_t *);
72 extern int safte_get_encstat(ses_softc_t *, int);
73 extern int safte_set_encstat(ses_softc_t *, uchar_t, int);
74 extern int safte_get_objstat(ses_softc_t *, ses_objarg *, int);
75 extern int safte_set_objstat(ses_softc_t *, ses_objarg *, int);
76
77 extern int sen_softc_init(ses_softc_t *, int);
78 extern int sen_init_enc(ses_softc_t *);
79 extern int sen_get_encstat(ses_softc_t *, int);
80 extern int sen_set_encstat(ses_softc_t *, uchar_t, int);
81 extern int sen_get_objstat(ses_softc_t *, ses_objarg *, int);
82 extern int sen_set_objstat(ses_softc_t *, ses_objarg *, int);
83
84 /*
85 * Local Function prototypes
86 */
87 static int ses_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
88 static int ses_probe(dev_info_t *);
89 static int ses_attach(dev_info_t *, ddi_attach_cmd_t);
90 static int ses_detach(dev_info_t *, ddi_detach_cmd_t);
91
92 static int is_enc_dev(ses_softc_t *, struct scsi_inquiry *, int, enctyp *);
93 static int ses_doattach(dev_info_t *dip);
94
95 static int ses_open(dev_t *, int, int, cred_t *);
96 static int ses_close(dev_t, int, int, cred_t *);
97 static int ses_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
98
99 static encvec vecs[3] = {
100 {
101 ses_softc_init, ses_init_enc, ses_get_encstat,
102 ses_set_encstat, ses_get_objstat, ses_set_objstat
103 },
104 {
105 safte_softc_init, safte_init_enc, safte_get_encstat,
106 safte_set_encstat, safte_get_objstat, safte_set_objstat,
107 },
108 {
109 sen_softc_init, sen_init_enc, sen_get_encstat,
110 sen_set_encstat, sen_get_objstat, sen_set_objstat
111 }
112 };
113
114
115 /*
116 * Local Functions
117 */
118 static int ses_start(struct buf *bp);
119 static int ses_decode_sense(struct scsi_pkt *pkt, int *err);
120
121 static void ses_get_pkt(struct buf *bp, int (*func)(opaque_t));
122 static void ses_callback(struct scsi_pkt *pkt);
123 static void ses_restart(void *arg);
124
125
126 /*
127 * Local Static Data
128 */
129 #ifndef D_HOTPLUG
130 #define D_HOTPLUG 0
131 #endif /* D_HOTPLUG */
132
133 static struct cb_ops ses_cb_ops = {
134 ses_open, /* open */
135 ses_close, /* close */
136 nodev, /* strategy */
137 nodev, /* print */
138 nodev, /* dump */
139 nodev, /* read */
140 nodev, /* write */
141 ses_ioctl, /* ioctl */
142 nodev, /* devmap */
143 nodev, /* mmap */
144 nodev, /* segmap */
145 nochpoll, /* poll */
146 ddi_prop_op, /* cb_prop_op */
147 0, /* streamtab */
148 #if !defined(CB_REV)
149 D_MP | D_NEW | D_HOTPLUG /* Driver compatibility flag */
150 #else /* !defined(CB_REV) */
151 D_MP | D_NEW | D_HOTPLUG, /* Driver compatibility flag */
152 CB_REV, /* cb_ops version number */
153 nodev, /* aread */
154 nodev /* awrite */
155 #endif /* !defined(CB_REV) */
156 };
157
158 static struct dev_ops ses_dev_ops = {
159 DEVO_REV, /* devo_rev, */
160 0, /* refcnt */
161 ses_info, /* info */
162 nulldev, /* identify */
163 ses_probe, /* probe */
164 ses_attach, /* attach */
165 ses_detach, /* detach */
166 nodev, /* reset */
167 &ses_cb_ops, /* driver operations */
168 (struct bus_ops *)NULL, /* bus operations */
169 NULL, /* power */
170 ddi_quiesce_not_needed, /* quiesce */
171 };
172
173 static void *estate = NULL;
174 static const char *Snm = "ses";
175 static const char *Str = "%s\n";
176 static const char *efl = "copyin/copyout EFAULT @ line %d";
177 static const char *fail_msg = "%stransport failed: reason '%s': %s";
178
179
180
181 /*
182 * autoconfiguration routines.
183 */
184
185 static struct modldrv modldrv = {
186 &mod_driverops,
187 "SCSI Enclosure Services",
188 &ses_dev_ops
189 };
190
191 static struct modlinkage modlinkage = {
192 MODREV_1, { &modldrv, NULL }
193 };
194
195
196 int
197 _init(void)
198 {
199 int status;
200 status = ddi_soft_state_init(&estate, sizeof (ses_softc_t), 0);
201 if (status == 0) {
202 if ((status = mod_install(&modlinkage)) != 0) {
203 ddi_soft_state_fini(&estate);
204 }
205 }
206 return (status);
207 }
208
209 int
210 _fini(void)
211 {
212 int status;
213 if ((status = mod_remove(&modlinkage)) != 0) {
214 return (status);
215 }
216 ddi_soft_state_fini(&estate);
217 return (status);
218 }
219
220 int
221 _info(struct modinfo *modinfop)
222 {
223 return (mod_info(&modlinkage, modinfop));
224 }
225
226 static int
227 ses_probe(dev_info_t *dip)
228 {
229 int err;
230 struct scsi_device *devp;
231 enctyp ep;
232
233 /*
234 * I finally figured out why we return success
235 * on every probe. The devices that we attach to
236 * don't all report as being the same "device type"
237 *
238 * 1) A5x00 -- report as Enclosure Services (0xD) SES
239 * 2) A1000 -- report as Direct Access (0x0) SES
240 * uses the same target as raid controler.
241 * 3) D1000 -- report as processor (0x3) SAFTE
242 * 3) D240 -- report as processor (0x3) SAFTE
243 *
244 * We also reportedly attach to SEN devices which I
245 * believe reside in a Tobasco tray. I have never
246 * been able to get one to attach.
247 *
248 */
249 if (dip == NULL)
250 return (DDI_PROBE_FAILURE);
251 /* SES_LOG(NULL, SES_CE_DEBUG1, "ses_probe: OK"); */
252 if (ddi_dev_is_sid(dip) == DDI_SUCCESS) {
253 return (DDI_PROBE_DONTCARE);
254 }
255
256 devp = ddi_get_driver_private(dip);
257
258 /* Legacy: prevent driver.conf specified ses nodes on atapi. */
259 if (scsi_ifgetcap(&devp->sd_address, "interconnect-type", -1) ==
260 INTERCONNECT_ATAPI)
261 return (DDI_PROBE_FAILURE);
262
263 /*
264 * XXX: Breakage from the x86 folks.
265 */
266 if (strcmp(ddi_get_name(ddi_get_parent(dip)), "ata") == 0) {
267 return (DDI_PROBE_FAILURE);
268 }
269
270 switch (err = scsi_probe(devp, SLEEP_FUNC)) {
271 case SCSIPROBE_EXISTS:
272 if (is_enc_dev(NULL, devp->sd_inq, SUN_INQSIZE, &ep)) {
273 break;
274 }
275 /* FALLTHROUGH */
276 case SCSIPROBE_NORESP:
277 scsi_unprobe(devp);
278 return (DDI_PROBE_FAILURE);
279 default:
280 SES_LOG(NULL, SES_CE_DEBUG9,
281 "ses_probe: probe error %d", err);
282 scsi_unprobe(devp);
283 return (DDI_PROBE_FAILURE);
284 }
285 scsi_unprobe(devp);
286 return (DDI_PROBE_SUCCESS);
287 }
288
289 static int
290 ses_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
291 {
292 int inst, err;
293 ses_softc_t *ssc;
294
295 inst = ddi_get_instance(dip);
296 switch (cmd) {
297 case DDI_ATTACH:
298 SES_LOG(NULL, SES_CE_DEBUG9, "ses_attach: DDI_ATTACH ses%d",
299 inst);
300
301 err = ses_doattach(dip);
302
303 if (err == DDI_FAILURE) {
304 return (DDI_FAILURE);
305 }
306 SES_LOG(NULL, SES_CE_DEBUG4,
307 "ses_attach: DDI_ATTACH OK ses%d", inst);
308 break;
309
310 case DDI_RESUME:
311 if ((ssc = ddi_get_soft_state(estate, inst)) == NULL) {
312 return (DDI_FAILURE);
313 }
314 SES_LOG(ssc, SES_CE_DEBUG1, "ses_attach: DDI_ATTACH ses%d",
315 inst);
316 ssc->ses_suspended = 0;
317 break;
318
319 default:
320 return (DDI_FAILURE);
321 }
322 return (DDI_SUCCESS);
323 }
324
325 static int
326 is_enc_dev(ses_softc_t *ssc, struct scsi_inquiry *inqp, int iqlen, enctyp *ep)
327 {
328 uchar_t dt = (inqp->inq_dtype & DTYPE_MASK);
329 uchar_t *iqd = (uchar_t *)inqp;
330
331 if (dt == DTYPE_ESI) {
332 if (strncmp(inqp->inq_vid, SEN_ID, SEN_ID_LEN) == 0) {
333 SES_LOG(ssc, SES_CE_DEBUG3, "SEN device found");
334 *ep = SEN_TYPE;
335 } else if (inqp->inq_rdf == RDF_SCSI2) {
336 /*
337 * Per SPC4 #6.4.2 Standard Inquiry Data, response
338 * data format (RDF) values of 0 and 1 are Obsolete,
339 * whereas values greater than 2 are Reserved
340 */
341 SES_LOG(ssc, SES_CE_DEBUG3, "SES device found");
342 *ep = SES_TYPE;
343 } else {
344 SES_LOG(ssc, SES_CE_DEBUG3, "Pre-SCSI3 SES device");
345 *ep = SES_TYPE;
346 }
347 return (1);
348 }
349 if ((iqd[6] & 0x40) && inqp->inq_rdf >= RDF_SCSI2) {
350 /*
351 * PassThrough Device.
352 */
353 *ep = SES_TYPE;
354 SES_LOG(ssc, SES_CE_DEBUG3, "Passthru SES device");
355 return (1);
356 }
357
358 if (iqlen < 47) {
359 SES_LOG(ssc, CE_NOTE,
360 "INQUIRY data too short to determine SAF-TE");
361 return (0);
362 }
363 if (strncmp((char *)&iqd[44], "SAF-TE", 4) == 0) {
364 *ep = SAFT_TYPE;
365 SES_LOG(ssc, SES_CE_DEBUG3, "SAF-TE device found");
366 return (1);
367 }
368 return (0);
369 }
370
371
372 /*
373 * Attach ses device.
374 *
375 * XXX: Power management is NOT supported. A token framework
376 * is provided that will need to be extended assuming we have
377 * ses devices we can power down. Currently, we don't have any.
378 */
379 static int
380 ses_doattach(dev_info_t *dip)
381 {
382 int inst, err;
383 Scsidevp devp;
384 ses_softc_t *ssc;
385 enctyp etyp;
386
387 inst = ddi_get_instance(dip);
388 /*
389 * Workaround for bug #4154979- for some reason we can
390 * be called with identical instance numbers but for
391 * different dev_info_t-s- all but one are bogus.
392 *
393 * Bad Dog! No Biscuit!
394 *
395 * A quick workaround might be to call ddi_soft_state_zalloc
396 * unconditionally, as the implementation fails these calls
397 * if there's an item already allocated. A more reasonable
398 * and longer term change is to move the allocation past
399 * the probe for the device's existence as most of these
400 * 'bogus' calls are for nonexistent devices.
401 */
402
403 devp = ddi_get_driver_private(dip);
404 devp->sd_dev = dip;
405
406 /*
407 * Determine whether the { i, t, l } we're called
408 * to start is an enclosure services device.
409 */
410
411 /*
412 * Call the scsi_probe routine to see whether
413 * we actually have an Enclosure Services device at
414 * this address.
415 */
416 err = scsi_probe(devp, SLEEP_FUNC);
417 if (err != SCSIPROBE_EXISTS) {
418 SES_LOG(NULL, SES_CE_DEBUG9,
419 "ses_doattach: probe error %d", err);
420 scsi_unprobe(devp);
421 return (DDI_FAILURE);
422 }
423 /* Call is_enc_dev() to get the etyp */
424 if (!(is_enc_dev(NULL, devp->sd_inq, SUN_INQSIZE, &etyp))) {
425 SES_LOG(NULL, CE_WARN,
426 "ses_doattach: ses%d: is_enc_dev failure", inst);
427 scsi_unprobe(devp);
428 return (DDI_FAILURE);
429 }
430
431 if (ddi_soft_state_zalloc(estate, inst) != DDI_SUCCESS) {
432 scsi_unprobe(devp);
433 SES_LOG(NULL, CE_NOTE, "ses%d: softalloc fails", inst);
434 return (DDI_FAILURE);
435 }
436 ssc = ddi_get_soft_state(estate, inst);
437 if (ssc == NULL) {
438 scsi_unprobe(devp);
439 SES_LOG(NULL, CE_NOTE, "ses%d: get_soft_state fails", inst);
440 return (DDI_FAILURE);
441 }
442 devp->sd_private = (opaque_t)ssc;
443 ssc->ses_devp = devp;
444 err = ddi_create_minor_node(dip, "0", S_IFCHR, inst,
445 DDI_NT_SCSI_ENCLOSURE, NULL);
446 if (err == DDI_FAILURE) {
447 ddi_remove_minor_node(dip, NULL);
448 SES_LOG(ssc, CE_NOTE, "minor node creation failed");
449 ddi_soft_state_free(estate, inst);
450 scsi_unprobe(devp);
451 return (DDI_FAILURE);
452 }
453
454 ssc->ses_type = etyp;
455 ssc->ses_vec = vecs[etyp];
456
457 /* Call SoftC Init Routine A bit later... */
458
459 ssc->ses_rqbp = scsi_alloc_consistent_buf(SES_ROUTE(ssc),
460 NULL, MAX_SENSE_LENGTH, B_READ, SLEEP_FUNC, NULL);
461 if (ssc->ses_rqbp != NULL) {
462 ssc->ses_rqpkt = scsi_init_pkt(SES_ROUTE(ssc), NULL,
463 ssc->ses_rqbp, CDB_GROUP0, 1, 0, PKT_CONSISTENT,
464 SLEEP_FUNC, NULL);
465 }
466 if (ssc->ses_rqbp == NULL || ssc->ses_rqpkt == NULL) {
467 ddi_remove_minor_node(dip, NULL);
468 SES_LOG(ssc, CE_NOTE, "scsi_init_pkt of rqbuf failed");
469 if (ssc->ses_rqbp != NULL) {
470 scsi_free_consistent_buf(ssc->ses_rqbp);
471 ssc->ses_rqbp = NULL;
472 }
473 ddi_soft_state_free(estate, inst);
474 scsi_unprobe(devp);
475 return (DDI_FAILURE);
476 }
477 ssc->ses_rqpkt->pkt_private = (opaque_t)ssc;
478 ssc->ses_rqpkt->pkt_address = *(SES_ROUTE(ssc));
479 ssc->ses_rqpkt->pkt_comp = ses_callback;
480 ssc->ses_rqpkt->pkt_time = ses_io_time;
481 ssc->ses_rqpkt->pkt_flags = FLAG_NOPARITY|FLAG_NODISCON|FLAG_SENSING;
482 ssc->ses_rqpkt->pkt_cdbp[0] = SCMD_REQUEST_SENSE;
483 ssc->ses_rqpkt->pkt_cdbp[1] = 0;
484 ssc->ses_rqpkt->pkt_cdbp[2] = 0;
485 ssc->ses_rqpkt->pkt_cdbp[3] = 0;
486 ssc->ses_rqpkt->pkt_cdbp[4] = MAX_SENSE_LENGTH;
487 ssc->ses_rqpkt->pkt_cdbp[5] = 0;
488
489 switch (scsi_ifgetcap(SES_ROUTE(ssc), "auto-rqsense", 1)) {
490 case 1:
491 /* if already set, don't reset it */
492 ssc->ses_arq = 1;
493 break;
494 case 0:
495 /* try and set it */
496 ssc->ses_arq = ((scsi_ifsetcap(SES_ROUTE(ssc),
497 "auto-rqsense", 1, 1) == 1) ? 1 : 0);
498 break;
499 default:
500 /* probably undefined, so zero it out */
501 ssc->ses_arq = 0;
502 break;
503 }
504
505 ssc->ses_sbufp = getrbuf(KM_SLEEP);
506 cv_init(&ssc->ses_sbufcv, NULL, CV_DRIVER, NULL);
507
508 /*
509 * If the HBA supports wide, tell it to use wide.
510 */
511 if (scsi_ifgetcap(SES_ROUTE(ssc), "wide-xfer", 1) != -1) {
512 int wd = ((devp->sd_inq->inq_rdf == RDF_SCSI2) &&
513 (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32))
514 ? 1 : 0;
515 (void) scsi_ifsetcap(SES_ROUTE(ssc), "wide-xfer", wd, 1);
516 }
517
518 /*
519 * Now do ssc init of enclosure specifics.
520 * At the same time, check to make sure getrbuf
521 * actually succeeded.
522 */
523 if ((*ssc->ses_vec.softc_init)(ssc, 1)) {
524 SES_LOG(ssc, SES_CE_DEBUG3, "failed softc init");
525 (void) (*ssc->ses_vec.softc_init)(ssc, 0);
526 ddi_remove_minor_node(dip, NULL);
527 scsi_destroy_pkt(ssc->ses_rqpkt);
528 scsi_free_consistent_buf(ssc->ses_rqbp);
529 if (ssc->ses_sbufp) {
530 freerbuf(ssc->ses_sbufp);
531 }
532 cv_destroy(&ssc->ses_sbufcv);
533 ddi_soft_state_free(estate, inst);
534 scsi_unprobe(devp);
535 return (DDI_FAILURE);
536 }
537
538 /*
539 * create this property so that PM code knows we want
540 * to be suspended at PM time
541 */
542 (void) ddi_prop_update_string(DDI_DEV_T_NONE, dip,
543 PM_HARDWARE_STATE_PROP, PM_NEEDS_SUSPEND_RESUME);
544
545 /* announce the existence of this device */
546 ddi_report_dev(dip);
547 return (DDI_SUCCESS);
548 }
549
550
551 /*
552 * Detach ses device.
553 *
554 * XXX: Power management is NOT supported. A token framework
555 * is provided that will need to be extended assuming we have
556 * ses devices we can power down. Currently, we don't have any.
557 */
558 static int
559 ses_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
560 {
561 ses_softc_t *ssc;
562 int inst;
563
564 switch (cmd) {
565 case DDI_DETACH:
566 inst = ddi_get_instance(dip);
567 ssc = ddi_get_soft_state(estate, inst);
568 if (ssc == NULL) {
569 cmn_err(CE_NOTE,
570 "ses%d: DDI_DETACH, no softstate found", inst);
571 return (DDI_FAILURE);
572 }
573 if (ISOPEN(ssc)) {
574 return (DDI_FAILURE);
575 }
576
577 #if !defined(lint)
578 /* LINTED */
579 _NOTE(COMPETING_THREADS_NOW);
580 #endif /* !defined(lint) */
581
582 if (ssc->ses_vec.softc_init)
583 (void) (*ssc->ses_vec.softc_init)(ssc, 0);
584
585 #if !defined(lint)
586 _NOTE(NO_COMPETING_THREADS_NOW);
587 #endif /* !defined(lint) */
588
589 (void) scsi_ifsetcap(SES_ROUTE(ssc), "auto-rqsense", 1, 0);
590 scsi_destroy_pkt(ssc->ses_rqpkt);
591 scsi_free_consistent_buf(ssc->ses_rqbp);
592 freerbuf(ssc->ses_sbufp);
593 cv_destroy(&ssc->ses_sbufcv);
594 ddi_soft_state_free(estate, inst);
595 ddi_prop_remove_all(dip);
596 ddi_remove_minor_node(dip, NULL);
597 scsi_unprobe(ddi_get_driver_private(dip));
598 break;
599
600 case DDI_SUSPEND:
601 inst = ddi_get_instance(dip);
602 if ((ssc = ddi_get_soft_state(estate, inst)) == NULL) {
603 cmn_err(CE_NOTE,
604 "ses%d: DDI_SUSPEND, no softstate found", inst);
605 return (DDI_FAILURE);
606 }
607
608 /*
609 * If driver idle, accept suspend request.
610 * If it's busy, reject it. This keeps things simple!
611 */
612 mutex_enter(SES_MUTEX);
613 if (ssc->ses_sbufbsy) {
614 mutex_exit(SES_MUTEX);
615 return (DDI_FAILURE);
616 }
617 ssc->ses_suspended = 1;
618 mutex_exit(SES_MUTEX);
619 break;
620
621 default:
622 return (DDI_FAILURE);
623 }
624 return (DDI_SUCCESS);
625 }
626
627 /* ARGSUSED */
628 static int
629 ses_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
630 {
631 dev_t dev;
632 ses_softc_t *ssc;
633 int inst, error;
634
635 switch (infocmd) {
636 case DDI_INFO_DEVT2DEVINFO:
637 dev = (dev_t)arg;
638 inst = getminor(dev);
639 if ((ssc = ddi_get_soft_state(estate, inst)) == NULL) {
640 return (DDI_FAILURE);
641 }
642 *result = (void *) ssc->ses_devp->sd_dev;
643 error = DDI_SUCCESS;
644 break;
645 case DDI_INFO_DEVT2INSTANCE:
646 dev = (dev_t)arg;
647 inst = getminor(dev);
648 *result = (void *)(uintptr_t)inst;
649 error = DDI_SUCCESS;
650 break;
651 default:
652 error = DDI_FAILURE;
653 }
654 return (error);
655 }
656
657
658 /*
659 * Unix Entry Points
660 */
661
662 /* ARGSUSED */
663 static int
664 ses_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
665 {
666 ses_softc_t *ssc;
667
668 if ((ssc = ddi_get_soft_state(estate, getminor(*dev_p))) == NULL) {
669 return (ENXIO);
670 }
671
672 /*
673 * If the device is powered down, request it's activation.
674 * If it can't be activated, fail open.
675 */
676 if (ssc->ses_suspended &&
677 ddi_dev_is_needed(SES_DEVINFO(ssc), 0, 1) != DDI_SUCCESS) {
678 return (EIO);
679 }
680
681 mutex_enter(SES_MUTEX);
682 if (otyp == OTYP_LYR)
683 ssc->ses_lyropen++;
684 else
685 ssc->ses_oflag = 1;
686
687 ssc->ses_present = (ssc->ses_present)? ssc->ses_present: SES_OPENING;
688 mutex_exit(SES_MUTEX);
689 return (EOK);
690 }
691
692 /*ARGSUSED*/
693 static int
694 ses_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
695 {
696 ses_softc_t *ssc;
697 if ((ssc = ddi_get_soft_state(estate, getminor(dev))) == NULL) {
698 return (ENXIO);
699 }
700
701 if (ssc->ses_suspended) {
702 (void) ddi_dev_is_needed(SES_DEVINFO(ssc), 0, 1);
703 }
704
705 mutex_enter(SES_MUTEX);
706 if (otyp == OTYP_LYR)
707 ssc->ses_lyropen -= (ssc->ses_lyropen)? 1: 0;
708 else
709 ssc->ses_oflag = 0;
710 mutex_exit(SES_MUTEX);
711 return (0);
712 }
713
714
715 /*ARGSUSED3*/
716 static int
717 ses_ioctl(dev_t dev, int cmd, intptr_t arg, int flg, cred_t *cred_p, int *rvalp)
718 {
719 ses_softc_t *ssc;
720 ses_object k, *up;
721 ses_objarg x;
722 uchar_t t;
723 uchar_t i;
724 int rv = 0;
725
726 if ((ssc = ddi_get_soft_state(estate, getminor(dev))) == NULL ||
727 ssc->ses_present == SES_CLOSED) {
728 return (ENXIO);
729 }
730
731
732 switch (cmd) {
733 case SESIOC_GETNOBJ:
734 if (ddi_copyout(&ssc->ses_nobjects, (void *)arg,
735 sizeof (int), flg)) {
736 rv = EFAULT;
737 break;
738 }
739 break;
740
741 case SESIOC_GETOBJMAP:
742 up = (ses_object *) arg;
743 mutex_enter(SES_MUTEX);
744 for (i = 0; i != ssc->ses_nobjects; i++) {
745 k.obj_id = i;
746 k.subencid = ssc->ses_objmap[i].subenclosure;
747 k.elem_type = ssc->ses_objmap[i].enctype;
748 if (ddi_copyout(&k, up, sizeof (k), flg)) {
749 rv = EFAULT;
750 break;
751 }
752 up++;
753 }
754 mutex_exit(SES_MUTEX);
755 break;
756
757 case SESIOC_INIT:
758 if (drv_priv(cred_p) != 0) {
759 rv = EPERM;
760 break;
761 }
762 rv = (*ssc->ses_vec.init_enc)(ssc);
763 break;
764
765 case SESIOC_GETENCSTAT:
766 if ((ssc->ses_encstat & ENCI_SVALID) == 0) {
767 rv = (*ssc->ses_vec.get_encstat)(ssc, KM_SLEEP);
768 if (rv) {
769 break;
770 }
771 }
772 t = ssc->ses_encstat & 0xf;
773 if (ddi_copyout(&t, (void *)arg, sizeof (t), flg))
774 rv = EFAULT;
775 /*
776 * And always invalidate enclosure status on the way out.
777 */
778 mutex_enter(SES_MUTEX);
779 ssc->ses_encstat &= ~ENCI_SVALID;
780 mutex_exit(SES_MUTEX);
781 break;
782
783 case SESIOC_SETENCSTAT:
784 if (drv_priv(cred_p) != 0) {
785 rv = EPERM;
786 break;
787 }
788 if (ddi_copyin((void *)arg, &t, sizeof (t), flg))
789 rv = EFAULT;
790 else
791 rv = (*ssc->ses_vec.set_encstat)(ssc, t, KM_SLEEP);
792 mutex_enter(SES_MUTEX);
793 ssc->ses_encstat &= ~ENCI_SVALID;
794 mutex_exit(SES_MUTEX);
795 break;
796
797 case SESIOC_GETOBJSTAT:
798 if (ddi_copyin((void *)arg, &x, sizeof (x), flg)) {
799 rv = EFAULT;
800 break;
801 }
802 if (x.obj_id >= ssc->ses_nobjects) {
803 rv = EINVAL;
804 break;
805 }
806 if ((rv = (*ssc->ses_vec.get_objstat)(ssc, &x, KM_SLEEP)) != 0)
807 break;
808 if (ddi_copyout(&x, (void *)arg, sizeof (x), flg))
809 rv = EFAULT;
810 else {
811 /*
812 * Now that we no longer poll, svalid never stays true.
813 */
814 mutex_enter(SES_MUTEX);
815 ssc->ses_objmap[x.obj_id].svalid = 0;
816 mutex_exit(SES_MUTEX);
817 }
818 break;
819
820 case SESIOC_SETOBJSTAT:
821 if (drv_priv(cred_p) != 0) {
822 rv = EPERM;
823 break;
824 }
825 if (ddi_copyin((void *)arg, &x, sizeof (x), flg)) {
826 rv = EFAULT;
827 break;
828 }
829 if (x.obj_id >= ssc->ses_nobjects) {
830 rv = EINVAL;
831 break;
832 }
833 rv = (*ssc->ses_vec.set_objstat)(ssc, &x, KM_SLEEP);
834 if (rv == 0) {
835 mutex_enter(SES_MUTEX);
836 ssc->ses_objmap[x.obj_id].svalid = 0;
837 mutex_exit(SES_MUTEX);
838 }
839 break;
840
841 case USCSICMD:
842 if (drv_priv(cred_p) != 0) {
843 rv = EPERM;
844 break;
845 }
846 rv = ses_uscsi_cmd(ssc, (Uscmd *)arg, flg);
847 break;
848
849 default:
850 rv = ENOTTY;
851 break;
852 }
853 return (rv);
854 }
855
856
857 /*
858 * Loop on running a kernel based command
859 *
860 * FIXME: This routine is not really needed.
861 */
862 int
863 ses_runcmd(ses_softc_t *ssc, Uscmd *lp)
864 {
865 int e;
866
867 lp->uscsi_status = 0;
868 e = ses_uscsi_cmd(ssc, lp, FKIOCTL);
869
870 #ifdef not
871 /*
872 * Debug: Nice cross-check code for verifying consistent status.
873 */
874 if (lp->uscsi_status) {
875 if (lp->uscsi_status == STATUS_CHECK) {
876 SES_LOG(ssc, CE_NOTE, "runcmd<cdb[0]="
877 "0x%x->%s ASC/ASCQ=0x%x/0x%x>",
878 lp->uscsi_cdb[0],
879 scsi_sname(lp->uscsi_rqbuf[2] & 0xf),
880 lp->uscsi_rqbuf[12] & 0xff,
881 lp->uscsi_rqbuf[13] & 0xff);
882 } else {
883 SES_LOG(ssc, CE_NOTE, "runcmd<cdb[0]="
884 "0x%x -> Status 0x%x", lp->uscsi_cdb[0],
885 lp->uscsi_status);
886 }
887 }
888 #endif /* not */
889 return (e);
890 }
891
892
893 /*
894 * Run a scsi command.
895 */
896 int
897 ses_uscsi_cmd(ses_softc_t *ssc, Uscmd *Uc, int Uf)
898 {
899 Uscmd *uscmd;
900 struct buf *bp;
901 enum uio_seg uioseg;
902 int err;
903
904 /*
905 * Grab local 'special' buffer
906 */
907 mutex_enter(SES_MUTEX);
908 while (ssc->ses_sbufbsy) {
909 cv_wait(&ssc->ses_sbufcv, &ssc->ses_devp->sd_mutex);
910 }
911 ssc->ses_sbufbsy = 1;
912 mutex_exit(SES_MUTEX);
913
914 /*
915 * If the device is powered down, request it's activation.
916 * This check must be done after setting ses_sbufbsy!
917 */
918 if (ssc->ses_suspended &&
919 ddi_dev_is_needed(SES_DEVINFO(ssc), 0, 1) != DDI_SUCCESS) {
920 mutex_enter(SES_MUTEX);
921 ssc->ses_sbufbsy = 0;
922 mutex_exit(SES_MUTEX);
923 return (EIO);
924 }
925
926 err = scsi_uscsi_alloc_and_copyin((intptr_t)Uc, Uf,
927 SES_ROUTE(ssc), &uscmd);
928 if (err != 0) {
929 SES_LOG(ssc, SES_CE_DEBUG1, "ses_uscsi_cmd: "
930 "scsi_uscsi_alloc_and_copyin failed\n");
931 mutex_enter(SES_MUTEX);
932 ssc->ses_sbufbsy = 0;
933 cv_signal(&ssc->ses_sbufcv);
934 mutex_exit(SES_MUTEX);
935 SES_LOG(ssc, SES_CE_DEBUG2, efl, __LINE__);
936 return (err);
937 }
938
939 /*
940 * Copy the uscsi command related infos to ssc for use in ses_start()
941 * and ses_callback().
942 */
943 bcopy(uscmd, &ssc->ses_uscsicmd, sizeof (Uscmd));
944 if (uscmd->uscsi_cdb != NULL) {
945 bcopy(uscmd->uscsi_cdb, &ssc->ses_srqcdb,
946 (size_t)(uscmd->uscsi_cdblen));
947 }
948 ssc->ses_uscsicmd.uscsi_status = 0;
949
950 bp = ssc->ses_sbufp;
951 bp->av_back = (struct buf *)NULL;
952 bp->av_forw = (struct buf *)NULL;
953 bp->b_back = (struct buf *)ssc;
954 bp->b_edev = NODEV;
955
956 if (uscmd->uscsi_cdb != NULL) {
957 if (uscmd->uscsi_cdblen == CDB_GROUP0) {
958 SES_LOG(ssc, SES_CE_DEBUG7,
959 "scsi_cmd: %x %x %x %x %x %x",
960 ((char *)uscmd->uscsi_cdb)[0],
961 ((char *)uscmd->uscsi_cdb)[1],
962 ((char *)uscmd->uscsi_cdb)[2],
963 ((char *)uscmd->uscsi_cdb)[3],
964 ((char *)uscmd->uscsi_cdb)[4],
965 ((char *)uscmd->uscsi_cdb)[5]);
966 } else {
967 SES_LOG(ssc, SES_CE_DEBUG7,
968 "scsi cmd: %x %x %x %x %x %x %x %x %x %x",
969 ((char *)uscmd->uscsi_cdb)[0],
970 ((char *)uscmd->uscsi_cdb)[1],
971 ((char *)uscmd->uscsi_cdb)[2],
972 ((char *)uscmd->uscsi_cdb)[3],
973 ((char *)uscmd->uscsi_cdb)[4],
974 ((char *)uscmd->uscsi_cdb)[5],
975 ((char *)uscmd->uscsi_cdb)[6],
976 ((char *)uscmd->uscsi_cdb)[7],
977 ((char *)uscmd->uscsi_cdb)[8],
978 ((char *)uscmd->uscsi_cdb)[9]);
979 }
980 }
981
982 uioseg = (Uf & FKIOCTL) ? UIO_SYSSPACE : UIO_USERSPACE;
983 err = scsi_uscsi_handle_cmd(NODEV, uioseg, uscmd,
984 ses_start, bp, NULL);
985
986 /*
987 * ses_callback() may set values for ssc->ses_uscsicmd or
988 * ssc->ses_srqsbuf, so copy them back to uscmd.
989 */
990 if (uscmd->uscsi_rqbuf != NULL) {
991 bcopy(&ssc->ses_srqsbuf, uscmd->uscsi_rqbuf,
992 (size_t)(uscmd->uscsi_rqlen));
993 uscmd->uscsi_rqresid = ssc->ses_uscsicmd.uscsi_rqresid;
994 }
995 uscmd->uscsi_status = ssc->ses_uscsicmd.uscsi_status;
996
997 (void) scsi_uscsi_copyout_and_free((intptr_t)Uc, uscmd);
998 mutex_enter(SES_MUTEX);
999 ssc->ses_sbufbsy = 0;
1000 cv_signal(&ssc->ses_sbufcv);
1001 mutex_exit(SES_MUTEX);
1002
1003 return (err);
1004 }
1005
1006
1007
1008 /*
1009 * Command start and done functions.
1010 */
1011 static int
1012 ses_start(struct buf *bp)
1013 {
1014 ses_softc_t *ssc = (ses_softc_t *)bp->b_back;
1015
1016 SES_LOG(ssc, SES_CE_DEBUG9, "ses_start");
1017 if (!BP_PKT(bp)) {
1018 /*
1019 * Allocate a packet.
1020 */
1021 ses_get_pkt(bp, SLEEP_FUNC);
1022 if (!BP_PKT(bp)) {
1023 int err;
1024 bp->b_resid = bp->b_bcount;
1025 if (geterror(bp) == 0)
1026 SET_BP_ERROR(bp, EIO);
1027 err = geterror(bp);
1028 biodone(bp);
1029 return (err);
1030 }
1031 }
1032
1033 /*
1034 * Initialize the transfer residue, error code, and retry count.
1035 */
1036 bp->b_resid = 0;
1037 SET_BP_ERROR(bp, 0);
1038
1039 #if !defined(lint)
1040 _NOTE(NO_COMPETING_THREADS_NOW);
1041 #endif /* !defined(lint) */
1042 ssc->ses_retries = ses_retry_count;
1043
1044 #if !defined(lint)
1045 /* LINTED */
1046 _NOTE(COMPETING_THREADS_NOW);
1047 #endif /* !defined(lint) */
1048
1049 SES_LOG(ssc, SES_CE_DEBUG9, "ses_start -> scsi_transport");
1050 switch (scsi_transport(BP_PKT(bp))) {
1051 case TRAN_ACCEPT:
1052 return (0);
1053 /* break; */
1054
1055 case TRAN_BUSY:
1056 SES_LOG(ssc, SES_CE_DEBUG2,
1057 "ses_start: TRANSPORT BUSY");
1058 SES_ENABLE_RESTART(SES_RESTART_TIME, BP_PKT(bp));
1059 return (0);
1060 /* break; */
1061
1062 default:
1063 SES_LOG(ssc, SES_CE_DEBUG2, "TRANSPORT ERROR\n");
1064 SET_BP_ERROR(bp, EIO);
1065 scsi_destroy_pkt(BP_PKT(bp));
1066 SET_BP_PKT(bp, NULL);
1067 biodone(bp);
1068 return (EIO);
1069 /* break; */
1070 }
1071 }
1072
1073
1074 static void
1075 ses_get_pkt(struct buf *bp, int (*func)())
1076 {
1077 ses_softc_t *ssc = (ses_softc_t *)bp->b_back;
1078 Uscmd *scmd = &ssc->ses_uscsicmd;
1079 struct scsi_pkt *pkt;
1080 int stat_size = 1;
1081 int flags = 0;
1082
1083 if ((scmd->uscsi_flags & USCSI_RQENABLE) && ssc->ses_arq) {
1084 if (scmd->uscsi_rqlen > SENSE_LENGTH) {
1085 stat_size = (int)(scmd->uscsi_rqlen) +
1086 sizeof (struct scsi_arq_status) -
1087 sizeof (struct scsi_extended_sense);
1088 flags = PKT_XARQ;
1089 } else {
1090 stat_size = sizeof (struct scsi_arq_status);
1091 }
1092 }
1093
1094 if (bp->b_bcount) {
1095 pkt = scsi_init_pkt(SES_ROUTE(ssc), NULL, bp,
1096 scmd->uscsi_cdblen, stat_size, 0, flags,
1097 func, (caddr_t)ssc);
1098 } else {
1099 pkt = scsi_init_pkt(SES_ROUTE(ssc), NULL, NULL,
1100 scmd->uscsi_cdblen, stat_size, 0, flags,
1101 func, (caddr_t)ssc);
1102 }
1103 SET_BP_PKT(bp, pkt);
1104 if (pkt == (struct scsi_pkt *)NULL)
1105 return;
1106 bcopy(scmd->uscsi_cdb, pkt->pkt_cdbp, (size_t)scmd->uscsi_cdblen);
1107
1108 /* Set an upper bound timeout of ses_io_time if zero is passed in */
1109 pkt->pkt_time = (scmd->uscsi_timeout == 0) ?
1110 ses_io_time : scmd->uscsi_timeout;
1111
1112 pkt->pkt_comp = ses_callback;
1113 pkt->pkt_private = (opaque_t)ssc;
1114 }
1115
1116
1117 /*
1118 * Restart ses command.
1119 */
1120 static void
1121 ses_restart(void *arg)
1122 {
1123 struct scsi_pkt *pkt = (struct scsi_pkt *)arg;
1124 ses_softc_t *ssc = (ses_softc_t *)pkt->pkt_private;
1125 struct buf *bp = ssc->ses_sbufp;
1126 SES_LOG(ssc, SES_CE_DEBUG9, "ses_restart");
1127
1128 ssc->ses_restart_id = NULL;
1129
1130 switch (scsi_transport(pkt)) {
1131 case TRAN_ACCEPT:
1132 SES_LOG(ssc, SES_CE_DEBUG9,
1133 "RESTART %d ok", ssc->ses_retries);
1134 return;
1135 /* break; */
1136 case TRAN_BUSY:
1137 SES_LOG(ssc, SES_CE_DEBUG1,
1138 "RESTART %d TRANSPORT BUSY\n", ssc->ses_retries);
1139 if (ssc->ses_retries > SES_NO_RETRY) {
1140 ssc->ses_retries -= SES_BUSY_RETRY;
1141 SES_ENABLE_RESTART(SES_RESTART_TIME, pkt);
1142 return;
1143 }
1144 SET_BP_ERROR(bp, EBUSY);
1145 break;
1146 default:
1147 SET_BP_ERROR(bp, EIO);
1148 break;
1149 }
1150 SES_LOG(ssc, SES_CE_DEBUG1,
1151 "RESTART %d TRANSPORT FAILED\n", ssc->ses_retries);
1152
1153 pkt = (struct scsi_pkt *)bp->av_back;
1154 scsi_destroy_pkt(pkt);
1155 bp->b_resid = bp->b_bcount;
1156 SET_BP_PKT(bp, NULL);
1157 biodone(bp);
1158 }
1159
1160
1161 /*
1162 * Command completion processing
1163 */
1164 #define HBA_RESET (STAT_BUS_RESET|STAT_DEV_RESET|STAT_ABORTED)
1165 static void
1166 ses_callback(struct scsi_pkt *pkt)
1167 {
1168 ses_softc_t *ssc = (ses_softc_t *)pkt->pkt_private;
1169 struct buf *bp;
1170 Uscmd *scmd;
1171 int err;
1172 char action;
1173
1174 bp = ssc->ses_sbufp;
1175 scmd = &ssc->ses_uscsicmd;
1176 /* SES_LOG(ssc, SES_CE_DEBUG9, "ses_callback"); */
1177
1178 /*
1179 * Optimization: Normal completion.
1180 */
1181 if (pkt->pkt_reason == CMD_CMPLT &&
1182 !SCBP_C(pkt) &&
1183 !(pkt->pkt_flags & FLAG_SENSING) &&
1184 !pkt->pkt_resid) {
1185 scsi_destroy_pkt(pkt);
1186 SET_BP_PKT(bp, NULL);
1187 biodone(bp);
1188 return;
1189 }
1190
1191
1192 /*
1193 * Abnormal completion.
1194 *
1195 * Assume most common error initially.
1196 */
1197 err = EIO;
1198 action = COMMAND_DONE;
1199 if (scmd->uscsi_flags & USCSI_DIAGNOSE) {
1200 ssc->ses_retries = SES_NO_RETRY;
1201 }
1202
1203 CHECK_PKT:
1204 if (pkt->pkt_reason != CMD_CMPLT) {
1205 /* Process transport errors. */
1206 switch (pkt->pkt_reason) {
1207 case CMD_TIMEOUT:
1208 /*
1209 * If the transport layer didn't clear the problem,
1210 * reset the target.
1211 */
1212 if (! (pkt->pkt_statistics & HBA_RESET)) {
1213 (void) scsi_reset(&pkt->pkt_address,
1214 RESET_TARGET);
1215 }
1216 err = ETIMEDOUT;
1217 break;
1218
1219 case CMD_INCOMPLETE:
1220 case CMD_UNX_BUS_FREE:
1221 /*
1222 * No response? If probing, give up.
1223 * Otherwise, keep trying until retries exhausted.
1224 * Then lockdown the driver as the device is
1225 * unplugged.
1226 */
1227 if (ssc->ses_retries <= SES_NO_RETRY &&
1228 !(scmd->uscsi_flags & USCSI_DIAGNOSE)) {
1229 ssc->ses_present = SES_CLOSED;
1230 }
1231 /* Inhibit retries to speed probe/attach. */
1232 if (ssc->ses_present < SES_OPEN) {
1233 ssc->ses_retries = SES_NO_RETRY;
1234 }
1235 /* SES_CMD_RETRY4(ssc->ses_retries); */
1236 err = ENXIO;
1237 break;
1238
1239 case CMD_DATA_OVR:
1240 /*
1241 * XXX: Some HBA's (e.g. Adaptec 1740 and
1242 * earlier ISP revs) report a DATA OVERRUN
1243 * error instead of a transfer residue. So,
1244 * we convert the error and restart.
1245 */
1246 if ((bp->b_bcount - pkt->pkt_resid) > 0) {
1247 SES_LOG(ssc, SES_CE_DEBUG6,
1248 "ignoring overrun");
1249 pkt->pkt_reason = CMD_CMPLT;
1250 err = EOK;
1251 goto CHECK_PKT;
1252 }
1253 ssc->ses_retries = SES_NO_RETRY;
1254 /* err = EIO; */
1255 break;
1256
1257 case CMD_DMA_DERR:
1258 ssc->ses_retries = SES_NO_RETRY;
1259 err = EFAULT;
1260 break;
1261
1262 default:
1263 /* err = EIO; */
1264 break;
1265 }
1266 if (pkt == ssc->ses_rqpkt) {
1267 SES_LOG(ssc, CE_WARN, fail_msg,
1268 "Request Sense ",
1269 scsi_rname(pkt->pkt_reason),
1270 (ssc->ses_retries > 0)?
1271 "retrying": "giving up");
1272 pkt = (struct scsi_pkt *)bp->av_back;
1273 action = QUE_SENSE;
1274 } else {
1275 SES_LOG(ssc, CE_WARN, fail_msg,
1276 "", scsi_rname(pkt->pkt_reason),
1277 (ssc->ses_retries > 0)?
1278 "retrying": "giving up");
1279 action = QUE_COMMAND;
1280 }
1281 /* Device exists, allow full error recovery. */
1282 if (ssc->ses_retries > SES_NO_RETRY) {
1283 ssc->ses_present = SES_OPEN;
1284 }
1285
1286
1287 /*
1288 * Process status and sense data errors.
1289 */
1290 } else {
1291 ssc->ses_present = SES_OPEN;
1292 action = ses_decode_sense(pkt, &err);
1293 }
1294
1295
1296 /*
1297 * Initiate error recovery action, as needed.
1298 */
1299 switch (action) {
1300 case QUE_COMMAND_NOW:
1301 /* SES_LOG(ssc, SES_CE_DEBUG1, "retrying cmd now"); */
1302 if (ssc->ses_retries > SES_NO_RETRY) {
1303 ssc->ses_retries -= SES_CMD_RETRY;
1304 scmd->uscsi_status = 0;
1305 if (ssc->ses_arq)
1306 bzero(pkt->pkt_scbp,
1307 sizeof (struct scsi_arq_status));
1308
1309 if (scsi_transport((struct scsi_pkt *)bp->av_back)
1310 != TRAN_ACCEPT) {
1311 SES_ENABLE_RESTART(SES_RESTART_TIME,
1312 (struct scsi_pkt *)bp->av_back);
1313 }
1314 return;
1315 }
1316 break;
1317
1318 case QUE_COMMAND:
1319 SES_LOG(ssc, SES_CE_DEBUG1, "retrying cmd");
1320 if (ssc->ses_retries > SES_NO_RETRY) {
1321 ssc->ses_retries -=
1322 (err == EBUSY)? SES_BUSY_RETRY: SES_CMD_RETRY;
1323 scmd->uscsi_status = 0;
1324 if (ssc->ses_arq)
1325 bzero(pkt->pkt_scbp,
1326 sizeof (struct scsi_arq_status));
1327
1328 SES_ENABLE_RESTART(
1329 (err == EBUSY)? SES_BUSY_TIME: SES_RESTART_TIME,
1330 (struct scsi_pkt *)bp->av_back);
1331 return;
1332 }
1333 break;
1334
1335 case QUE_SENSE:
1336 SES_LOG(ssc, SES_CE_DEBUG1, "retrying sense");
1337 if (ssc->ses_retries > SES_NO_RETRY) {
1338 ssc->ses_retries -= SES_SENSE_RETRY;
1339 scmd->uscsi_status = 0;
1340 bzero(&ssc->ses_srqsbuf, MAX_SENSE_LENGTH);
1341
1342 if (scsi_transport(ssc->ses_rqpkt) != TRAN_ACCEPT) {
1343 SES_ENABLE_RESTART(SES_RESTART_TIME,
1344 ssc->ses_rqpkt);
1345 }
1346 return;
1347 }
1348 break;
1349
1350 case COMMAND_DONE:
1351 SES_LOG(ssc, SES_CE_DEBUG4, "cmd done");
1352 pkt = (struct scsi_pkt *)bp->av_back;
1353 bp->b_resid = pkt->pkt_resid;
1354 if (bp->b_resid) {
1355 SES_LOG(ssc, SES_CE_DEBUG6,
1356 "transfer residue %ld(%ld)",
1357 bp->b_bcount - bp->b_resid, bp->b_bcount);
1358 }
1359 break;
1360 }
1361 pkt = (struct scsi_pkt *)bp->av_back;
1362 if (err) {
1363 SES_LOG(ssc, SES_CE_DEBUG1, "SES: ERROR %d\n", err);
1364 SET_BP_ERROR(bp, err);
1365 bp->b_resid = bp->b_bcount;
1366 }
1367 scsi_destroy_pkt(pkt);
1368 SET_BP_PKT(bp, NULL);
1369 biodone(bp);
1370 }
1371
1372
1373 /*
1374 * Check status and sense data and determine recovery.
1375 */
1376 static int
1377 ses_decode_sense(struct scsi_pkt *pkt, int *err)
1378 {
1379 ses_softc_t *ssc = (ses_softc_t *)pkt->pkt_private;
1380 struct scsi_extended_sense *sense =
1381 (struct scsi_extended_sense *)&ssc->ses_srqsbuf;
1382 Uscmd *scmd = &ssc->ses_uscsicmd;
1383 char sense_flag = 0;
1384 uchar_t status = SCBP_C(pkt) & STATUS_MASK;
1385 char *err_action;
1386 char action;
1387 uchar_t rqlen;
1388 int amt;
1389
1390 /*
1391 * Process manual request sense.
1392 * Copy manual request sense to sense buffer.
1393 *
1394 * This is done if auto request sense is not enabled.
1395 * Or the auto request sense failed and the request
1396 * sense needs to be retried.
1397 */
1398 if (pkt->pkt_flags & FLAG_SENSING) {
1399 struct buf *sbp = ssc->ses_rqbp;
1400 amt = min(MAX_SENSE_LENGTH,
1401 sbp->b_bcount - sbp->b_resid);
1402 rqlen = min((uchar_t)amt, scmd->uscsi_rqlen);
1403 bcopy(sbp->b_un.b_addr, sense, rqlen);
1404 scmd->uscsi_rqresid = scmd->uscsi_rqlen - rqlen;
1405 sense_flag = 1;
1406 /*
1407 * Process auto request sense.
1408 * Copy auto request sense to sense buffer.
1409 *
1410 * If auto request sense failed due to transport error,
1411 * retry the command. Otherwise process the status and
1412 * sense data.
1413 */
1414 } else if (ssc->ses_arq && pkt->pkt_state & STATE_ARQ_DONE) {
1415 struct scsi_arq_status *arq =
1416 (struct scsi_arq_status *)(pkt->pkt_scbp);
1417 uchar_t *arq_status = (uchar_t *)&arq->sts_rqpkt_status;
1418 if (pkt->pkt_state & STATE_XARQ_DONE) {
1419 amt = MAX_SENSE_LENGTH - arq->sts_rqpkt_resid;
1420 } else {
1421 if (arq->sts_rqpkt_resid > SENSE_LENGTH) {
1422 amt = MAX_SENSE_LENGTH - arq->sts_rqpkt_resid;
1423 } else {
1424 amt = SENSE_LENGTH - arq->sts_rqpkt_resid;
1425 }
1426 }
1427
1428 if (arq->sts_rqpkt_reason != CMD_CMPLT) {
1429 return (QUE_COMMAND);
1430 }
1431
1432 rqlen = min((uchar_t)amt, scmd->uscsi_rqlen);
1433 bcopy(&arq->sts_sensedata, sense, rqlen);
1434 scmd->uscsi_status = status;
1435 scmd->uscsi_rqresid = scmd->uscsi_rqlen - rqlen;
1436 status = *arq_status & STATUS_MASK;
1437 pkt->pkt_state &= ~STATE_ARQ_DONE;
1438 sense_flag = 1;
1439 }
1440
1441
1442 /*
1443 * Check status of REQUEST SENSE or command.
1444 *
1445 * If it's not successful, try retrying the original command
1446 * and hope that it goes away. If not, we'll eventually run
1447 * out of retries and die.
1448 */
1449 switch (status) {
1450 case STATUS_GOOD:
1451 case STATUS_INTERMEDIATE:
1452 case STATUS_MET:
1453 /*
1454 * If the command status is ok, we're done.
1455 * Otherwise, examine the request sense data.
1456 */
1457 if (! sense_flag) {
1458 *err = EOK;
1459 return (COMMAND_DONE);
1460 }
1461 break;
1462
1463 case STATUS_CHECK:
1464 SES_LOG(ssc, SES_CE_DEBUG3, "status decode: check");
1465 *err = EIO;
1466 return (QUE_SENSE);
1467 /* break; */
1468
1469 case STATUS_BUSY:
1470 SES_LOG(ssc, SES_CE_DEBUG1, "status decode: busy");
1471 /* SES_CMD_RETRY2(ssc->ses_retries); */
1472 *err = EBUSY;
1473 return (QUE_COMMAND);
1474 /* break; */
1475
1476 case STATUS_RESERVATION_CONFLICT:
1477 SES_LOG(ssc, SES_CE_DEBUG1, "status decode: reserved");
1478 *err = EACCES;
1479 return (COMMAND_DONE_ERROR);
1480 /* break; */
1481
1482 case STATUS_TERMINATED:
1483 SES_LOG(ssc, SES_CE_DEBUG1, "status decode: terminated");
1484 *err = ECANCELED;
1485 return (COMMAND_DONE_ERROR);
1486 /* break; */
1487
1488 default:
1489 SES_LOG(ssc, SES_CE_DEBUG1, "status 0x%x", status);
1490 *err = EIO;
1491 return (QUE_COMMAND);
1492 /* break; */
1493 }
1494
1495
1496 /*
1497 * Check REQUEST SENSE error code.
1498 *
1499 * Either there's no error, a retryable error,
1500 * or it's dead. SES devices aren't very complex.
1501 */
1502 err_action = "retrying";
1503 switch (sense->es_key) {
1504 case KEY_RECOVERABLE_ERROR:
1505 *err = EOK;
1506 err_action = "recovered";
1507 action = COMMAND_DONE;
1508 break;
1509
1510 case KEY_UNIT_ATTENTION:
1511 /*
1512 * This is common for RAID!
1513 */
1514 /* *err = EIO; */
1515 SES_CMD_RETRY1(ssc->ses_retries);
1516 action = QUE_COMMAND_NOW;
1517 break;
1518
1519 case KEY_NOT_READY:
1520 case KEY_NO_SENSE:
1521 /* *err = EIO; */
1522 action = QUE_COMMAND;
1523 break;
1524
1525 default:
1526 /* *err = EIO; */
1527 err_action = "fatal";
1528 action = COMMAND_DONE_ERROR;
1529 break;
1530 }
1531 SES_LOG(ssc, SES_CE_DEBUG1,
1532 "cdb[0]= 0x%x %s, key=0x%x, ASC/ASCQ=0x%x/0x%x",
1533 scmd->uscsi_cdb[0], err_action,
1534 sense->es_key, sense->es_add_code, sense->es_qual_code);
1535
1536 #ifdef not
1537 /*
1538 * Dump cdb and sense data stat's for manufacturing.
1539 */
1540 if (DEBUGGING_ERR || sd_error_level == SDERR_ALL) {
1541 auto buf[128];
1542
1543 p = pkt->pkt_cdbp;
1544 if ((j = scsi_cdb_size[CDB_GROUPID(*p)]) == 0)
1545 j = CDB_SIZE;
1546
1547 /* Print cdb */
1548 (void) sprintf(buf, "cmd:");
1549 for (i = 0; i < j; i++) {
1550 (void) sprintf(&buf[strlen(buf)],
1551 hex, (uchar_t)*p++);
1552 }
1553 SES_LOG(ssc, SES_CE_DEBUG3, "%s", buf);
1554
1555 /* Suppress trailing zero's in sense data */
1556 if (amt > 3) {
1557 p = (char *)devp->sd_sense + amt;
1558 for (j = amt; j > 3; j--) {
1559 if (*(--p)) break;
1560 }
1561 } else {
1562 j = amt;
1563 }
1564
1565 /* Print sense data. */
1566 (void) sprintf(buf, "sense:");
1567 p = (char *)devp->sd_sense;
1568 for (i = 0; i < j; i++) {
1569 (void) sprintf(&buf[strlen(buf)],
1570 hex, (uchar_t)*p++);
1571 }
1572 SES_LOG(ssc, SES_CE_DEBUG3, "%s", buf);
1573 }
1574 #endif /* not */
1575 return (action);
1576 }
1577
1578
1579 /*PRINTFLIKE3*/
1580 void
1581 ses_log(ses_softc_t *ssc, int level, const char *fmt, ...)
1582 {
1583 va_list ap;
1584 char buf[256];
1585
1586 va_start(ap, fmt);
1587 (void) vsprintf(buf, fmt, ap);
1588 va_end(ap);
1589
1590 if (ssc == (ses_softc_t *)NULL) {
1591 switch (level) {
1592 case SES_CE_DEBUG1:
1593 if (ses_debug > 1)
1594 cmn_err(CE_NOTE, "%s", buf);
1595 break;
1596 case SES_CE_DEBUG2:
1597 if (ses_debug > 2)
1598 cmn_err(CE_NOTE, "%s", buf);
1599 break;
1600 case SES_CE_DEBUG3:
1601 if (ses_debug > 3)
1602 cmn_err(CE_NOTE, "%s", buf);
1603 break;
1604 case SES_CE_DEBUG4:
1605 if (ses_debug > 4)
1606 cmn_err(CE_NOTE, "%s", buf);
1607 break;
1608 case SES_CE_DEBUG5:
1609 if (ses_debug > 5)
1610 cmn_err(CE_NOTE, "%s", buf);
1611 break;
1612 case SES_CE_DEBUG6:
1613 if (ses_debug > 6)
1614 cmn_err(CE_NOTE, "%s", buf);
1615 break;
1616 case SES_CE_DEBUG7:
1617 if (ses_debug > 7)
1618 cmn_err(CE_NOTE, "%s", buf);
1619 break;
1620 case SES_CE_DEBUG8:
1621 if (ses_debug > 8)
1622 cmn_err(CE_NOTE, "%s", buf);
1623 break;
1624 case SES_CE_DEBUG9:
1625 if (ses_debug > 9)
1626 cmn_err(CE_NOTE, "%s", buf);
1627 break;
1628 case CE_NOTE:
1629 case CE_WARN:
1630 case CE_PANIC:
1631 cmn_err(level, "%s", buf);
1632 break;
1633 case SES_CE_DEBUG:
1634 default:
1635 cmn_err(CE_NOTE, "%s", buf);
1636 break;
1637 }
1638 return;
1639 }
1640
1641 switch (level) {
1642 case CE_CONT:
1643 case CE_NOTE:
1644 case CE_WARN:
1645 case CE_PANIC:
1646 scsi_log(SES_DEVINFO(ssc), (char *)Snm, level, Str, buf);
1647 break;
1648 case SES_CE_DEBUG1:
1649 if (ses_debug > 1)
1650 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1651 Str, buf);
1652 break;
1653 case SES_CE_DEBUG2:
1654 if (ses_debug > 2)
1655 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1656 Str, buf);
1657 break;
1658 case SES_CE_DEBUG3:
1659 if (ses_debug > 3)
1660 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1661 Str, buf);
1662 break;
1663 case SES_CE_DEBUG4:
1664 if (ses_debug > 4)
1665 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1666 Str, buf);
1667 break;
1668 case SES_CE_DEBUG5:
1669 if (ses_debug > 5)
1670 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1671 Str, buf);
1672 break;
1673 case SES_CE_DEBUG6:
1674 if (ses_debug > 6)
1675 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1676 Str, buf);
1677 break;
1678 case SES_CE_DEBUG7:
1679 if (ses_debug > 7)
1680 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1681 Str, buf);
1682 break;
1683 case SES_CE_DEBUG8:
1684 if (ses_debug > 8)
1685 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1686 Str, buf);
1687 break;
1688 case SES_CE_DEBUG9:
1689 if (ses_debug > 9)
1690 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG,
1691 Str, buf);
1692 break;
1693 case SES_CE_DEBUG:
1694 default:
1695 scsi_log(SES_DEVINFO(ssc), (char *)Snm, SCSI_DEBUG, Str, buf);
1696 break;
1697 }
1698 }
1699 /*
1700 * mode: c
1701 * Local variables:
1702 * c-indent-level: 8
1703 * c-brace-imaginary-offset: 0
1704 * c-brace-offset: -8
1705 * c-argdecl-indent: 8
1706 * c-label-offset: -8
1707 * c-continued-statement-offset: 8
1708 * c-continued-brace-offset: 0
1709 * End:
1710 */