1 /* $NetBSD: scsipi_base.c,v 1.148 2008/05/11 05:17:23 mlelstv Exp $ */
2
3 /*-
4 * Copyright (c) 1998, 1999, 2000, 2002, 2003, 2004 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Charles M. Hannum; by Jason R. Thorpe of the Numerical Aerospace
9 * Simulation Facility, NASA Ames Research Center.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: scsipi_base.c,v 1.148 2008/05/11 05:17:23 mlelstv Exp $");
35
36 #include "opt_scsi.h"
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/kernel.h>
41 #include <sys/buf.h>
42 #include <sys/uio.h>
43 #include <sys/malloc.h>
44 #include <sys/pool.h>
45 #include <sys/errno.h>
46 #include <sys/device.h>
47 #include <sys/proc.h>
48 #include <sys/kthread.h>
49 #include <sys/hash.h>
50
51 #include <uvm/uvm_extern.h>
52
53 #include <dev/scsipi/scsi_spc.h>
54 #include <dev/scsipi/scsipi_all.h>
55 #include <dev/scsipi/scsipi_disk.h>
56 #include <dev/scsipi/scsipiconf.h>
57 #include <dev/scsipi/scsipi_base.h>
58
59 #include <dev/scsipi/scsi_all.h>
60 #include <dev/scsipi/scsi_message.h>
61
62 static int scsipi_complete(struct scsipi_xfer *);
63 static void scsipi_request_sense(struct scsipi_xfer *);
64 static int scsipi_enqueue(struct scsipi_xfer *);
65 static void scsipi_run_queue(struct scsipi_channel *chan);
66
67 static void scsipi_completion_thread(void *);
68
69 static void scsipi_get_tag(struct scsipi_xfer *);
70 static void scsipi_put_tag(struct scsipi_xfer *);
71
72 static int scsipi_get_resource(struct scsipi_channel *);
73 static void scsipi_put_resource(struct scsipi_channel *);
74
75 static void scsipi_async_event_max_openings(struct scsipi_channel *,
76 struct scsipi_max_openings *);
77 static void scsipi_async_event_xfer_mode(struct scsipi_channel *,
78 struct scsipi_xfer_mode *);
79 static void scsipi_async_event_channel_reset(struct scsipi_channel *);
80
81 static struct pool scsipi_xfer_pool;
82
83 /*
84 * scsipi_init:
85 *
86 * Called when a scsibus or atapibus is attached to the system
87 * to initialize shared data structures.
88 */
89 void
90 scsipi_init(void)
91 {
92 static int scsipi_init_done;
93
94 if (scsipi_init_done)
95 return;
96 scsipi_init_done = 1;
97
98 /* Initialize the scsipi_xfer pool. */
99 pool_init(&scsipi_xfer_pool, sizeof(struct scsipi_xfer), 0,
100 0, 0, "scxspl", NULL, IPL_BIO);
101 if (pool_prime(&scsipi_xfer_pool,
102 PAGE_SIZE / sizeof(struct scsipi_xfer)) == ENOMEM) {
103 printf("WARNING: not enough memory for scsipi_xfer_pool\n");
104 }
105 }
106
107 /*
108 * scsipi_channel_init:
109 *
110 * Initialize a scsipi_channel when it is attached.
111 */
112 int
113 scsipi_channel_init(struct scsipi_channel *chan)
114 {
115 struct scsipi_adapter *adapt = chan->chan_adapter;
116 int i;
117
118 /* Initialize shared data. */
119 scsipi_init();
120
121 /* Initialize the queues. */
122 TAILQ_INIT(&chan->chan_queue);
123 TAILQ_INIT(&chan->chan_complete);
124
125 for (i = 0; i < SCSIPI_CHAN_PERIPH_BUCKETS; i++)
126 LIST_INIT(&chan->chan_periphtab[i]);
127
128 /*
129 * Create the asynchronous completion thread.
130 */
131 if (kthread_create(PRI_NONE, 0, NULL, scsipi_completion_thread, chan,
132 &chan->chan_thread, "%s", chan->chan_name)) {
133 aprint_error_dev(adapt->adapt_dev, "unable to create completion thread for "
134 "channel %d\n", chan->chan_channel);
135 panic("scsipi_channel_init");
136 }
137
138 return (0);
139 }
140
141 /*
142 * scsipi_channel_shutdown:
143 *
144 * Shutdown a scsipi_channel.
145 */
146 void
147 scsipi_channel_shutdown(struct scsipi_channel *chan)
148 {
149
150 /*
151 * Shut down the completion thread.
152 */
153 chan->chan_tflags |= SCSIPI_CHANT_SHUTDOWN;
154 wakeup(&chan->chan_complete);
155
156 /*
157 * Now wait for the thread to exit.
158 */
159 while (chan->chan_thread != NULL)
160 (void) tsleep(&chan->chan_thread, PRIBIO, "scshut", 0);
161 }
162
163 static uint32_t
164 scsipi_chan_periph_hash(uint64_t t, uint64_t l)
165 {
166 uint32_t hash;
167
168 hash = hash32_buf(&t, sizeof(t), HASH32_BUF_INIT);
169 hash = hash32_buf(&l, sizeof(l), hash);
170
171 return (hash & SCSIPI_CHAN_PERIPH_HASHMASK);
172 }
173
174 /*
175 * scsipi_insert_periph:
176 *
177 * Insert a periph into the channel.
178 */
179 void
180 scsipi_insert_periph(struct scsipi_channel *chan, struct scsipi_periph *periph)
181 {
182 uint32_t hash;
183 int s;
184
185 hash = scsipi_chan_periph_hash(periph->periph_target,
186 periph->periph_lun);
187
188 s = splbio();
189 LIST_INSERT_HEAD(&chan->chan_periphtab[hash], periph, periph_hash);
190 splx(s);
191 }
192
193 /*
194 * scsipi_remove_periph:
195 *
196 * Remove a periph from the channel.
197 */
198 void
199 scsipi_remove_periph(struct scsipi_channel *chan,
200 struct scsipi_periph *periph)
201 {
202 int s;
203
204 s = splbio();
205 LIST_REMOVE(periph, periph_hash);
206 splx(s);
207 }
208
209 /*
210 * scsipi_lookup_periph:
211 *
212 * Lookup a periph on the specified channel.
213 */
214 struct scsipi_periph *
215 scsipi_lookup_periph(struct scsipi_channel *chan, int target, int lun)
216 {
217 struct scsipi_periph *periph;
218 uint32_t hash;
219 int s;
220
221 if (target >= chan->chan_ntargets ||
222 lun >= chan->chan_nluns)
223 return (NULL);
224
225 hash = scsipi_chan_periph_hash(target, lun);
226
227 s = splbio();
228 LIST_FOREACH(periph, &chan->chan_periphtab[hash], periph_hash) {
229 if (periph->periph_target == target &&
230 periph->periph_lun == lun)
231 break;
232 }
233 splx(s);
234
235 return (periph);
236 }
237
238 /*
239 * scsipi_get_resource:
240 *
241 * Allocate a single xfer `resource' from the channel.
242 *
243 * NOTE: Must be called at splbio().
244 */
245 static int
246 scsipi_get_resource(struct scsipi_channel *chan)
247 {
248 struct scsipi_adapter *adapt = chan->chan_adapter;
249
250 if (chan->chan_flags & SCSIPI_CHAN_OPENINGS) {
251 if (chan->chan_openings > 0) {
252 chan->chan_openings--;
253 return (1);
254 }
255 return (0);
256 }
257
258 if (adapt->adapt_openings > 0) {
259 adapt->adapt_openings--;
260 return (1);
261 }
262 return (0);
263 }
264
265 /*
266 * scsipi_grow_resources:
267 *
268 * Attempt to grow resources for a channel. If this succeeds,
269 * we allocate one for our caller.
270 *
271 * NOTE: Must be called at splbio().
272 */
273 static inline int
274 scsipi_grow_resources(struct scsipi_channel *chan)
275 {
276
277 if (chan->chan_flags & SCSIPI_CHAN_CANGROW) {
278 if ((chan->chan_flags & SCSIPI_CHAN_TACTIVE) == 0) {
279 scsipi_adapter_request(chan,
280 ADAPTER_REQ_GROW_RESOURCES, NULL);
281 return (scsipi_get_resource(chan));
282 }
283 /*
284 * ask the channel thread to do it. It'll have to thaw the
285 * queue
286 */
287 scsipi_channel_freeze(chan, 1);
288 chan->chan_tflags |= SCSIPI_CHANT_GROWRES;
289 wakeup(&chan->chan_complete);
290 return (0);
291 }
292
293 return (0);
294 }
295
296 /*
297 * scsipi_put_resource:
298 *
299 * Free a single xfer `resource' to the channel.
300 *
301 * NOTE: Must be called at splbio().
302 */
303 static void
304 scsipi_put_resource(struct scsipi_channel *chan)
305 {
306 struct scsipi_adapter *adapt = chan->chan_adapter;
307
308 if (chan->chan_flags & SCSIPI_CHAN_OPENINGS)
309 chan->chan_openings++;
310 else
311 adapt->adapt_openings++;
312 }
313
314 /*
315 * scsipi_get_tag:
316 *
317 * Get a tag ID for the specified xfer.
318 *
319 * NOTE: Must be called at splbio().
320 */
321 static void
322 scsipi_get_tag(struct scsipi_xfer *xs)
323 {
324 struct scsipi_periph *periph = xs->xs_periph;
325 int bit, tag;
326 u_int word;
327
328 bit = 0; /* XXX gcc */
329 for (word = 0; word < PERIPH_NTAGWORDS; word++) {
330 bit = ffs(periph->periph_freetags[word]);
331 if (bit != 0)
332 break;
333 }
334 #ifdef DIAGNOSTIC
335 if (word == PERIPH_NTAGWORDS) {
336 scsipi_printaddr(periph);
337 printf("no free tags\n");
338 panic("scsipi_get_tag");
339 }
340 #endif
341
342 bit -= 1;
343 periph->periph_freetags[word] &= ~(1 << bit);
344 tag = (word << 5) | bit;
345
346 /* XXX Should eventually disallow this completely. */
347 if (tag >= periph->periph_openings) {
348 scsipi_printaddr(periph);
349 printf("WARNING: tag %d greater than available openings %d\n",
350 tag, periph->periph_openings);
351 }
352
353 xs->xs_tag_id = tag;
354 }
355
356 /*
357 * scsipi_put_tag:
358 *
359 * Put the tag ID for the specified xfer back into the pool.
360 *
361 * NOTE: Must be called at splbio().
362 */
363 static void
364 scsipi_put_tag(struct scsipi_xfer *xs)
365 {
366 struct scsipi_periph *periph = xs->xs_periph;
367 int word, bit;
368
369 word = xs->xs_tag_id >> 5;
370 bit = xs->xs_tag_id & 0x1f;
371
372 periph->periph_freetags[word] |= (1 << bit);
373 }
374
375 /*
376 * scsipi_get_xs:
377 *
378 * Allocate an xfer descriptor and associate it with the
379 * specified peripherial. If the peripherial has no more
380 * available command openings, we either block waiting for
381 * one to become available, or fail.
382 */
383 struct scsipi_xfer *
384 scsipi_get_xs(struct scsipi_periph *periph, int flags)
385 {
386 struct scsipi_xfer *xs;
387 int s;
388
389 SC_DEBUG(periph, SCSIPI_DB3, ("scsipi_get_xs\n"));
390
391 KASSERT(!cold);
392
393 #ifdef DIAGNOSTIC
394 /*
395 * URGENT commands can never be ASYNC.
396 */
397 if ((flags & (XS_CTL_URGENT|XS_CTL_ASYNC)) ==
398 (XS_CTL_URGENT|XS_CTL_ASYNC)) {
399 scsipi_printaddr(periph);
400 printf("URGENT and ASYNC\n");
401 panic("scsipi_get_xs");
402 }
403 #endif
404
405 s = splbio();
406 /*
407 * Wait for a command opening to become available. Rules:
408 *
409 * - All xfers must wait for an available opening.
410 * Exception: URGENT xfers can proceed when
411 * active == openings, because we use the opening
412 * of the command we're recovering for.
413 * - if the periph has sense pending, only URGENT & REQSENSE
414 * xfers may proceed.
415 *
416 * - If the periph is recovering, only URGENT xfers may
417 * proceed.
418 *
419 * - If the periph is currently executing a recovery
420 * command, URGENT commands must block, because only
421 * one recovery command can execute at a time.
422 */
423 for (;;) {
424 if (flags & XS_CTL_URGENT) {
425 if (periph->periph_active > periph->periph_openings)
426 goto wait_for_opening;
427 if (periph->periph_flags & PERIPH_SENSE) {
428 if ((flags & XS_CTL_REQSENSE) == 0)
429 goto wait_for_opening;
430 } else {
431 if ((periph->periph_flags &
432 PERIPH_RECOVERY_ACTIVE) != 0)
433 goto wait_for_opening;
434 periph->periph_flags |= PERIPH_RECOVERY_ACTIVE;
435 }
436 break;
437 }
438 if (periph->periph_active >= periph->periph_openings ||
439 (periph->periph_flags & PERIPH_RECOVERING) != 0)
440 goto wait_for_opening;
441 periph->periph_active++;
442 break;
443
444 wait_for_opening:
445 if (flags & XS_CTL_NOSLEEP) {
446 splx(s);
447 return (NULL);
448 }
449 SC_DEBUG(periph, SCSIPI_DB3, ("sleeping\n"));
450 periph->periph_flags |= PERIPH_WAITING;
451 (void) tsleep(periph, PRIBIO, "getxs", 0);
452 }
453 SC_DEBUG(periph, SCSIPI_DB3, ("calling pool_get\n"));
454 xs = pool_get(&scsipi_xfer_pool,
455 ((flags & XS_CTL_NOSLEEP) != 0 ? PR_NOWAIT : PR_WAITOK));
456 if (xs == NULL) {
457 if (flags & XS_CTL_URGENT) {
458 if ((flags & XS_CTL_REQSENSE) == 0)
459 periph->periph_flags &= ~PERIPH_RECOVERY_ACTIVE;
460 } else
461 periph->periph_active--;
462 scsipi_printaddr(periph);
463 printf("unable to allocate %sscsipi_xfer\n",
464 (flags & XS_CTL_URGENT) ? "URGENT " : "");
465 }
466 splx(s);
467
468 SC_DEBUG(periph, SCSIPI_DB3, ("returning\n"));
469
470 if (xs != NULL) {
471 memset(xs, 0, sizeof(*xs));
472 callout_init(&xs->xs_callout, 0);
473 xs->xs_periph = periph;
474 xs->xs_control = flags;
475 xs->xs_status = 0;
476 s = splbio();
477 TAILQ_INSERT_TAIL(&periph->periph_xferq, xs, device_q);
478 splx(s);
479 }
480 return (xs);
481 }
482
483 /*
484 * scsipi_put_xs:
485 *
486 * Release an xfer descriptor, decreasing the outstanding command
487 * count for the peripherial. If there is a thread waiting for
488 * an opening, wake it up. If not, kick any queued I/O the
489 * peripherial may have.
490 *
491 * NOTE: Must be called at splbio().
492 */
493 void
494 scsipi_put_xs(struct scsipi_xfer *xs)
495 {
496 struct scsipi_periph *periph = xs->xs_periph;
497 int flags = xs->xs_control;
498
499 SC_DEBUG(periph, SCSIPI_DB3, ("scsipi_free_xs\n"));
500
501 TAILQ_REMOVE(&periph->periph_xferq, xs, device_q);
502 pool_put(&scsipi_xfer_pool, xs);
503
504 #ifdef DIAGNOSTIC
505 if ((periph->periph_flags & PERIPH_RECOVERY_ACTIVE) != 0 &&
506 periph->periph_active == 0) {
507 scsipi_printaddr(periph);
508 printf("recovery without a command to recovery for\n");
509 panic("scsipi_put_xs");
510 }
511 #endif
512
513 if (flags & XS_CTL_URGENT) {
514 if ((flags & XS_CTL_REQSENSE) == 0)
515 periph->periph_flags &= ~PERIPH_RECOVERY_ACTIVE;
516 } else
517 periph->periph_active--;
518 if (periph->periph_active == 0 &&
519 (periph->periph_flags & PERIPH_WAITDRAIN) != 0) {
520 periph->periph_flags &= ~PERIPH_WAITDRAIN;
521 wakeup(&periph->periph_active);
522 }
523
524 if (periph->periph_flags & PERIPH_WAITING) {
525 periph->periph_flags &= ~PERIPH_WAITING;
526 wakeup(periph);
527 } else {
528 if (periph->periph_switch->psw_start != NULL &&
529 device_is_active(periph->periph_dev)) {
530 SC_DEBUG(periph, SCSIPI_DB2,
531 ("calling private start()\n"));
532 (*periph->periph_switch->psw_start)(periph);
533 }
534 }
535 }
536
537 /*
538 * scsipi_channel_freeze:
539 *
540 * Freeze a channel's xfer queue.
541 */
542 void
543 scsipi_channel_freeze(struct scsipi_channel *chan, int count)
544 {
545 int s;
546
547 s = splbio();
548 chan->chan_qfreeze += count;
549 splx(s);
550 }
551
552 /*
553 * scsipi_channel_thaw:
554 *
555 * Thaw a channel's xfer queue.
556 */
557 void
558 scsipi_channel_thaw(struct scsipi_channel *chan, int count)
559 {
560 int s;
561
562 s = splbio();
563 chan->chan_qfreeze -= count;
564 /*
565 * Don't let the freeze count go negative.
566 *
567 * Presumably the adapter driver could keep track of this,
568 * but it might just be easier to do this here so as to allow
569 * multiple callers, including those outside the adapter driver.
570 */
571 if (chan->chan_qfreeze < 0) {
572 chan->chan_qfreeze = 0;
573 }
574 splx(s);
575 /*
576 * Kick the channel's queue here. Note, we may be running in
577 * interrupt context (softclock or HBA's interrupt), so the adapter
578 * driver had better not sleep.
579 */
580 if (chan->chan_qfreeze == 0)
581 scsipi_run_queue(chan);
582 }
583
584 /*
585 * scsipi_channel_timed_thaw:
586 *
587 * Thaw a channel after some time has expired. This will also
588 * run the channel's queue if the freeze count has reached 0.
589 */
590 void
591 scsipi_channel_timed_thaw(void *arg)
592 {
593 struct scsipi_channel *chan = arg;
594
595 scsipi_channel_thaw(chan, 1);
596 }
597
598 /*
599 * scsipi_periph_freeze:
600 *
601 * Freeze a device's xfer queue.
602 */
603 void
604 scsipi_periph_freeze(struct scsipi_periph *periph, int count)
605 {
606 int s;
607
608 s = splbio();
609 periph->periph_qfreeze += count;
610 splx(s);
611 }
612
613 /*
614 * scsipi_periph_thaw:
615 *
616 * Thaw a device's xfer queue.
617 */
618 void
619 scsipi_periph_thaw(struct scsipi_periph *periph, int count)
620 {
621 int s;
622
623 s = splbio();
624 periph->periph_qfreeze -= count;
625 #ifdef DIAGNOSTIC
626 if (periph->periph_qfreeze < 0) {
627 static const char pc[] = "periph freeze count < 0";
628 scsipi_printaddr(periph);
629 printf("%s\n", pc);
630 panic(pc);
631 }
632 #endif
633 if (periph->periph_qfreeze == 0 &&
634 (periph->periph_flags & PERIPH_WAITING) != 0)
635 wakeup(periph);
636 splx(s);
637 }
638
639 /*
640 * scsipi_periph_timed_thaw:
641 *
642 * Thaw a device after some time has expired.
643 */
644 void
645 scsipi_periph_timed_thaw(void *arg)
646 {
647 int s;
648 struct scsipi_periph *periph = arg;
649
650 callout_stop(&periph->periph_callout);
651
652 s = splbio();
653 scsipi_periph_thaw(periph, 1);
654 if ((periph->periph_channel->chan_flags & SCSIPI_CHAN_TACTIVE) == 0) {
655 /*
656 * Kick the channel's queue here. Note, we're running in
657 * interrupt context (softclock), so the adapter driver
658 * had better not sleep.
659 */
660 scsipi_run_queue(periph->periph_channel);
661 } else {
662 /*
663 * Tell the completion thread to kick the channel's queue here.
664 */
665 periph->periph_channel->chan_tflags |= SCSIPI_CHANT_KICK;
666 wakeup(&periph->periph_channel->chan_complete);
667 }
668 splx(s);
669 }
670
671 /*
672 * scsipi_wait_drain:
673 *
674 * Wait for a periph's pending xfers to drain.
675 */
676 void
677 scsipi_wait_drain(struct scsipi_periph *periph)
678 {
679 int s;
680
681 s = splbio();
682 while (periph->periph_active != 0) {
683 periph->periph_flags |= PERIPH_WAITDRAIN;
684 (void) tsleep(&periph->periph_active, PRIBIO, "sxdrn", 0);
685 }
686 splx(s);
687 }
688
689 /*
690 * scsipi_kill_pending:
691 *
692 * Kill off all pending xfers for a periph.
693 *
694 * NOTE: Must be called at splbio().
695 */
696 void
697 scsipi_kill_pending(struct scsipi_periph *periph)
698 {
699
700 (*periph->periph_channel->chan_bustype->bustype_kill_pending)(periph);
701 scsipi_wait_drain(periph);
702 }
703
704 /*
705 * scsipi_print_cdb:
706 * prints a command descriptor block (for debug purpose, error messages,
707 * SCSIPI_VERBOSE, ...)
708 */
709 void
710 scsipi_print_cdb(struct scsipi_generic *cmd)
711 {
712 int i, j;
713
714 printf("0x%02x", cmd->opcode);
715
716 switch (CDB_GROUPID(cmd->opcode)) {
717 case CDB_GROUPID_0:
718 j = CDB_GROUP0;
719 break;
720 case CDB_GROUPID_1:
721 j = CDB_GROUP1;
722 break;
723 case CDB_GROUPID_2:
724 j = CDB_GROUP2;
725 break;
726 case CDB_GROUPID_3:
727 j = CDB_GROUP3;
728 break;
729 case CDB_GROUPID_4:
730 j = CDB_GROUP4;
731 break;
732 case CDB_GROUPID_5:
733 j = CDB_GROUP5;
734 break;
735 case CDB_GROUPID_6:
736 j = CDB_GROUP6;
737 break;
738 case CDB_GROUPID_7:
739 j = CDB_GROUP7;
740 break;
741 default:
742 j = 0;
743 }
744 if (j == 0)
745 j = sizeof (cmd->bytes);
746 for (i = 0; i < j-1; i++) /* already done the opcode */
747 printf(" %02x", cmd->bytes[i]);
748 }
749
750 /*
751 * scsipi_interpret_sense:
752 *
753 * Look at the returned sense and act on the error, determining
754 * the unix error number to pass back. (0 = report no error)
755 *
756 * NOTE: If we return ERESTART, we are expected to haved
757 * thawed the device!
758 *
759 * THIS IS THE DEFAULT ERROR HANDLER FOR SCSI DEVICES.
760 */
761 int
762 scsipi_interpret_sense(struct scsipi_xfer *xs)
763 {
764 struct scsi_sense_data *sense;
765 struct scsipi_periph *periph = xs->xs_periph;
766 u_int8_t key;
767 int error;
768 #ifndef SCSIVERBOSE
769 u_int32_t info;
770 static const char *error_mes[] = {
771 "soft error (corrected)",
772 "not ready", "medium error",
773 "non-media hardware failure", "illegal request",
774 "unit attention", "readonly device",
775 "no data found", "vendor unique",
776 "copy aborted", "command aborted",
777 "search returned equal", "volume overflow",
778 "verify miscompare", "unknown error key"
779 };
780 #endif
781
782 sense = &xs->sense.scsi_sense;
783 #ifdef SCSIPI_DEBUG
784 if (periph->periph_flags & SCSIPI_DB1) {
785 int count;
786 scsipi_printaddr(periph);
787 printf(" sense debug information:\n");
788 printf("\tcode 0x%x valid %d\n",
789 SSD_RCODE(sense->response_code),
790 sense->response_code & SSD_RCODE_VALID ? 1 : 0);
791 printf("\tseg 0x%x key 0x%x ili 0x%x eom 0x%x fmark 0x%x\n",
792 sense->segment,
793 SSD_SENSE_KEY(sense->flags),
794 sense->flags & SSD_ILI ? 1 : 0,
795 sense->flags & SSD_EOM ? 1 : 0,
796 sense->flags & SSD_FILEMARK ? 1 : 0);
797 printf("\ninfo: 0x%x 0x%x 0x%x 0x%x followed by %d "
798 "extra bytes\n",
799 sense->info[0],
800 sense->info[1],
801 sense->info[2],
802 sense->info[3],
803 sense->extra_len);
804 printf("\textra: ");
805 for (count = 0; count < SSD_ADD_BYTES_LIM(sense); count++)
806 printf("0x%x ", sense->csi[count]);
807 printf("\n");
808 }
809 #endif
810
811 /*
812 * If the periph has it's own error handler, call it first.
813 * If it returns a legit error value, return that, otherwise
814 * it wants us to continue with normal error processing.
815 */
816 if (periph->periph_switch->psw_error != NULL) {
817 SC_DEBUG(periph, SCSIPI_DB2,
818 ("calling private err_handler()\n"));
819 error = (*periph->periph_switch->psw_error)(xs);
820 if (error != EJUSTRETURN)
821 return (error);
822 }
823 /* otherwise use the default */
824 switch (SSD_RCODE(sense->response_code)) {
825
826 /*
827 * Old SCSI-1 and SASI devices respond with
828 * codes other than 70.
829 */
830 case 0x00: /* no error (command completed OK) */
831 return (0);
832 case 0x04: /* drive not ready after it was selected */
833 if ((periph->periph_flags & PERIPH_REMOVABLE) != 0)
834 periph->periph_flags &= ~PERIPH_MEDIA_LOADED;
835 if ((xs->xs_control & XS_CTL_IGNORE_NOT_READY) != 0)
836 return (0);
837 /* XXX - display some sort of error here? */
838 return (EIO);
839 case 0x20: /* invalid command */
840 if ((xs->xs_control &
841 XS_CTL_IGNORE_ILLEGAL_REQUEST) != 0)
842 return (0);
843 return (EINVAL);
844 case 0x25: /* invalid LUN (Adaptec ACB-4000) */
845 return (EACCES);
846
847 /*
848 * If it's code 70, use the extended stuff and
849 * interpret the key
850 */
851 case 0x71: /* delayed error */
852 scsipi_printaddr(periph);
853 key = SSD_SENSE_KEY(sense->flags);
854 printf(" DEFERRED ERROR, key = 0x%x\n", key);
855 /* FALLTHROUGH */
856 case 0x70:
857 #ifndef SCSIVERBOSE
858 if ((sense->response_code & SSD_RCODE_VALID) != 0)
859 info = _4btol(sense->info);
860 else
861 info = 0;
862 #endif
863 key = SSD_SENSE_KEY(sense->flags);
864
865 switch (key) {
866 case SKEY_NO_SENSE:
867 case SKEY_RECOVERED_ERROR:
868 if (xs->resid == xs->datalen && xs->datalen) {
869 /*
870 * Why is this here?
871 */
872 xs->resid = 0; /* not short read */
873 }
874 case SKEY_EQUAL:
875 error = 0;
876 break;
877 case SKEY_NOT_READY:
878 if ((periph->periph_flags & PERIPH_REMOVABLE) != 0)
879 periph->periph_flags &= ~PERIPH_MEDIA_LOADED;
880 if ((xs->xs_control & XS_CTL_IGNORE_NOT_READY) != 0)
881 return (0);
882 if (sense->asc == 0x3A) {
883 error = ENODEV; /* Medium not present */
884 if (xs->xs_control & XS_CTL_SILENT_NODEV)
885 return (error);
886 } else
887 error = EIO;
888 if ((xs->xs_control & XS_CTL_SILENT) != 0)
889 return (error);
890 break;
891 case SKEY_ILLEGAL_REQUEST:
892 if ((xs->xs_control &
893 XS_CTL_IGNORE_ILLEGAL_REQUEST) != 0)
894 return (0);
895 /*
896 * Handle the case where a device reports
897 * Logical Unit Not Supported during discovery.
898 */
899 if ((xs->xs_control & XS_CTL_DISCOVERY) != 0 &&
900 sense->asc == 0x25 &&
901 sense->ascq == 0x00)
902 return (EINVAL);
903 if ((xs->xs_control & XS_CTL_SILENT) != 0)
904 return (EIO);
905 error = EINVAL;
906 break;
907 case SKEY_UNIT_ATTENTION:
908 if (sense->asc == 0x29 &&
909 sense->ascq == 0x00) {
910 /* device or bus reset */
911 return (ERESTART);
912 }
913 if ((periph->periph_flags & PERIPH_REMOVABLE) != 0)
914 periph->periph_flags &= ~PERIPH_MEDIA_LOADED;
915 if ((xs->xs_control &
916 XS_CTL_IGNORE_MEDIA_CHANGE) != 0 ||
917 /* XXX Should reupload any transient state. */
918 (periph->periph_flags &
919 PERIPH_REMOVABLE) == 0) {
920 return (ERESTART);
921 }
922 if ((xs->xs_control & XS_CTL_SILENT) != 0)
923 return (EIO);
924 error = EIO;
925 break;
926 case SKEY_DATA_PROTECT:
927 error = EROFS;
928 break;
929 case SKEY_BLANK_CHECK:
930 error = 0;
931 break;
932 case SKEY_ABORTED_COMMAND:
933 if (xs->xs_retries != 0) {
934 xs->xs_retries--;
935 error = ERESTART;
936 } else
937 error = EIO;
938 break;
939 case SKEY_VOLUME_OVERFLOW:
940 error = ENOSPC;
941 break;
942 default:
943 error = EIO;
944 break;
945 }
946
947 #ifdef SCSIVERBOSE
948 if (key && (xs->xs_control & XS_CTL_SILENT) == 0)
949 scsipi_print_sense(xs, 0);
950 #else
951 if (key) {
952 scsipi_printaddr(periph);
953 printf("%s", error_mes[key - 1]);
954 if ((sense->response_code & SSD_RCODE_VALID) != 0) {
955 switch (key) {
956 case SKEY_NOT_READY:
957 case SKEY_ILLEGAL_REQUEST:
958 case SKEY_UNIT_ATTENTION:
959 case SKEY_DATA_PROTECT:
960 break;
961 case SKEY_BLANK_CHECK:
962 printf(", requested size: %d (decimal)",
963 info);
964 break;
965 case SKEY_ABORTED_COMMAND:
966 if (xs->xs_retries)
967 printf(", retrying");
968 printf(", cmd 0x%x, info 0x%x",
969 xs->cmd->opcode, info);
970 break;
971 default:
972 printf(", info = %d (decimal)", info);
973 }
974 }
975 if (sense->extra_len != 0) {
976 int n;
977 printf(", data =");
978 for (n = 0; n < sense->extra_len; n++)
979 printf(" %02x",
980 sense->csi[n]);
981 }
982 printf("\n");
983 }
984 #endif
985 return (error);
986
987 /*
988 * Some other code, just report it
989 */
990 default:
991 #if defined(SCSIDEBUG) || defined(DEBUG)
992 {
993 static const char *uc = "undecodable sense error";
994 int i;
995 u_int8_t *cptr = (u_int8_t *) sense;
996 scsipi_printaddr(periph);
997 if (xs->cmd == &xs->cmdstore) {
998 printf("%s for opcode 0x%x, data=",
999 uc, xs->cmdstore.opcode);
1000 } else {
1001 printf("%s, data=", uc);
1002 }
1003 for (i = 0; i < sizeof (sense); i++)
1004 printf(" 0x%02x", *(cptr++) & 0xff);
1005 printf("\n");
1006 }
1007 #else
1008 scsipi_printaddr(periph);
1009 printf("Sense Error Code 0x%x",
1010 SSD_RCODE(sense->response_code));
1011 if ((sense->response_code & SSD_RCODE_VALID) != 0) {
1012 struct scsi_sense_data_unextended *usense =
1013 (struct scsi_sense_data_unextended *)sense;
1014 printf(" at block no. %d (decimal)",
1015 _3btol(usense->block));
1016 }
1017 printf("\n");
1018 #endif
1019 return (EIO);
1020 }
1021 }
1022
1023 /*
1024 * scsipi_test_unit_ready:
1025 *
1026 * Issue a `test unit ready' request.
1027 */
1028 int
1029 scsipi_test_unit_ready(struct scsipi_periph *periph, int flags)
1030 {
1031 struct scsi_test_unit_ready cmd;
1032 int retries;
1033
1034 /* some ATAPI drives don't support TEST UNIT READY. Sigh */
1035 if (periph->periph_quirks & PQUIRK_NOTUR)
1036 return (0);
1037
1038 if (flags & XS_CTL_DISCOVERY)
1039 retries = 0;
1040 else
1041 retries = SCSIPIRETRIES;
1042
1043 memset(&cmd, 0, sizeof(cmd));
1044 cmd.opcode = SCSI_TEST_UNIT_READY;
1045
1046 return (scsipi_command(periph, (void *)&cmd, sizeof(cmd), 0, 0,
1047 retries, 10000, NULL, flags));
1048 }
1049
1050 /*
1051 * scsipi_inquire:
1052 *
1053 * Ask the device about itself.
1054 */
1055 int
1056 scsipi_inquire(struct scsipi_periph *periph, struct scsipi_inquiry_data *inqbuf,
1057 int flags)
1058 {
1059 struct scsipi_inquiry cmd;
1060 int error;
1061 int retries;
1062
1063 if (flags & XS_CTL_DISCOVERY)
1064 retries = 0;
1065 else
1066 retries = SCSIPIRETRIES;
1067
1068 /*
1069 * If we request more data than the device can provide, it SHOULD just
1070 * return a short reponse. However, some devices error with an
1071 * ILLEGAL REQUEST sense code, and yet others have even more special
1072 * failture modes (such as the GL641USB flash adapter, which goes loony
1073 * and sends corrupted CRCs). To work around this, and to bring our
1074 * behavior more in line with other OSes, we do a shorter inquiry,
1075 * covering all the SCSI-2 information, first, and then request more
1076 * data iff the "additional length" field indicates there is more.
1077 * - mycroft, 2003/10/16
1078 */
1079 memset(&cmd, 0, sizeof(cmd));
1080 cmd.opcode = INQUIRY;
1081 cmd.length = SCSIPI_INQUIRY_LENGTH_SCSI2;
1082 error = scsipi_command(periph, (void *)&cmd, sizeof(cmd),
1083 (void *)inqbuf, SCSIPI_INQUIRY_LENGTH_SCSI2, retries,
1084 10000, NULL, flags | XS_CTL_DATA_IN);
1085 if (!error &&
1086 inqbuf->additional_length > SCSIPI_INQUIRY_LENGTH_SCSI2 - 4) {
1087 #if 0
1088 printf("inquire: addlen=%d, retrying\n", inqbuf->additional_length);
1089 #endif
1090 cmd.length = SCSIPI_INQUIRY_LENGTH_SCSI3;
1091 error = scsipi_command(periph, (void *)&cmd, sizeof(cmd),
1092 (void *)inqbuf, SCSIPI_INQUIRY_LENGTH_SCSI3, retries,
1093 10000, NULL, flags | XS_CTL_DATA_IN);
1094 #if 0
1095 printf("inquire: error=%d\n", error);
1096 #endif
1097 }
1098
1099 #ifdef SCSI_OLD_NOINQUIRY
1100 /*
1101 * Kludge for the Adaptec ACB-4000 SCSI->MFM translator.
1102 * This board doesn't support the INQUIRY command at all.
1103 */
1104 if (error == EINVAL || error == EACCES) {
1105 /*
1106 * Conjure up an INQUIRY response.
1107 */
1108 inqbuf->device = (error == EINVAL ?
1109 SID_QUAL_LU_PRESENT :
1110 SID_QUAL_LU_NOTPRESENT) | T_DIRECT;
1111 inqbuf->dev_qual2 = 0;
1112 inqbuf->version = 0;
1113 inqbuf->response_format = SID_FORMAT_SCSI1;
1114 inqbuf->additional_length = SCSIPI_INQUIRY_LENGTH_SCSI2 - 4;
1115 inqbuf->flags1 = inqbuf->flags2 = inqbuf->flags3 = 0;
1116 memcpy(inqbuf->vendor, "ADAPTEC ACB-4000 ", 28);
1117 error = 0;
1118 }
1119
1120 /*
1121 * Kludge for the Emulex MT-02 SCSI->QIC translator.
1122 * This board gives an empty response to an INQUIRY command.
1123 */
1124 else if (error == 0 &&
1125 inqbuf->device == (SID_QUAL_LU_PRESENT | T_DIRECT) &&
1126 inqbuf->dev_qual2 == 0 &&
1127 inqbuf->version == 0 &&
1128 inqbuf->response_format == SID_FORMAT_SCSI1) {
1129 /*
1130 * Fill out the INQUIRY response.
1131 */
1132 inqbuf->device = (SID_QUAL_LU_PRESENT | T_SEQUENTIAL);
1133 inqbuf->dev_qual2 = SID_REMOVABLE;
1134 inqbuf->additional_length = SCSIPI_INQUIRY_LENGTH_SCSI2 - 4;
1135 inqbuf->flags1 = inqbuf->flags2 = inqbuf->flags3 = 0;
1136 memcpy(inqbuf->vendor, "EMULEX MT-02 QIC ", 28);
1137 }
1138 #endif /* SCSI_OLD_NOINQUIRY */
1139
1140 return error;
1141 }
1142
1143 /*
1144 * scsipi_prevent:
1145 *
1146 * Prevent or allow the user to remove the media
1147 */
1148 int
1149 scsipi_prevent(struct scsipi_periph *periph, int type, int flags)
1150 {
1151 struct scsi_prevent_allow_medium_removal cmd;
1152
1153 if (periph->periph_quirks & PQUIRK_NODOORLOCK)
1154 return 0;
1155
1156 memset(&cmd, 0, sizeof(cmd));
1157 cmd.opcode = SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL;
1158 cmd.how = type;
1159
1160 return (scsipi_command(periph, (void *)&cmd, sizeof(cmd), 0, 0,
1161 SCSIPIRETRIES, 5000, NULL, flags));
1162 }
1163
1164 /*
1165 * scsipi_start:
1166 *
1167 * Send a START UNIT.
1168 */
1169 int
1170 scsipi_start(struct scsipi_periph *periph, int type, int flags)
1171 {
1172 struct scsipi_start_stop cmd;
1173
1174 memset(&cmd, 0, sizeof(cmd));
1175 cmd.opcode = START_STOP;
1176 cmd.byte2 = 0x00;
1177 cmd.how = type;
1178
1179 return (scsipi_command(periph, (void *)&cmd, sizeof(cmd), 0, 0,
1180 SCSIPIRETRIES, (type & SSS_START) ? 60000 : 10000, NULL, flags));
1181 }
1182
1183 /*
1184 * scsipi_mode_sense, scsipi_mode_sense_big:
1185 * get a sense page from a device
1186 */
1187
1188 int
1189 scsipi_mode_sense(struct scsipi_periph *periph, int byte2, int page,
1190 struct scsi_mode_parameter_header_6 *data, int len, int flags, int retries,
1191 int timeout)
1192 {
1193 struct scsi_mode_sense_6 cmd;
1194
1195 memset(&cmd, 0, sizeof(cmd));
1196 cmd.opcode = SCSI_MODE_SENSE_6;
1197 cmd.byte2 = byte2;
1198 cmd.page = page;
1199 cmd.length = len & 0xff;
1200
1201 return (scsipi_command(periph, (void *)&cmd, sizeof(cmd),
1202 (void *)data, len, retries, timeout, NULL, flags | XS_CTL_DATA_IN));
1203 }
1204
1205 int
1206 scsipi_mode_sense_big(struct scsipi_periph *periph, int byte2, int page,
1207 struct scsi_mode_parameter_header_10 *data, int len, int flags, int retries,
1208 int timeout)
1209 {
1210 struct scsi_mode_sense_10 cmd;
1211
1212 memset(&cmd, 0, sizeof(cmd));
1213 cmd.opcode = SCSI_MODE_SENSE_10;
1214 cmd.byte2 = byte2;
1215 cmd.page = page;
1216 _lto2b(len, cmd.length);
1217
1218 return (scsipi_command(periph, (void *)&cmd, sizeof(cmd),
1219 (void *)data, len, retries, timeout, NULL, flags | XS_CTL_DATA_IN));
1220 }
1221
1222 int
1223 scsipi_mode_select(struct scsipi_periph *periph, int byte2,
1224 struct scsi_mode_parameter_header_6 *data, int len, int flags, int retries,
1225 int timeout)
1226 {
1227 struct scsi_mode_select_6 cmd;
1228
1229 memset(&cmd, 0, sizeof(cmd));
1230 cmd.opcode = SCSI_MODE_SELECT_6;
1231 cmd.byte2 = byte2;
1232 cmd.length = len & 0xff;
1233
1234 return (scsipi_command(periph, (void *)&cmd, sizeof(cmd),
1235 (void *)data, len, retries, timeout, NULL, flags | XS_CTL_DATA_OUT));
1236 }
1237
1238 int
1239 scsipi_mode_select_big(struct scsipi_periph *periph, int byte2,
1240 struct scsi_mode_parameter_header_10 *data, int len, int flags, int retries,
1241 int timeout)
1242 {
1243 struct scsi_mode_select_10 cmd;
1244
1245 memset(&cmd, 0, sizeof(cmd));
1246 cmd.opcode = SCSI_MODE_SELECT_10;
1247 cmd.byte2 = byte2;
1248 _lto2b(len, cmd.length);
1249
1250 return (scsipi_command(periph, (void *)&cmd, sizeof(cmd),
1251 (void *)data, len, retries, timeout, NULL, flags | XS_CTL_DATA_OUT));
1252 }
1253
1254 /*
1255 * scsipi_done:
1256 *
1257 * This routine is called by an adapter's interrupt handler when
1258 * an xfer is completed.
1259 */
1260 void
1261 scsipi_done(struct scsipi_xfer *xs)
1262 {
1263 struct scsipi_periph *periph = xs->xs_periph;
1264 struct scsipi_channel *chan = periph->periph_channel;
1265 int s, freezecnt;
1266
1267 SC_DEBUG(periph, SCSIPI_DB2, ("scsipi_done\n"));
1268 #ifdef SCSIPI_DEBUG
1269 if (periph->periph_dbflags & SCSIPI_DB1)
1270 show_scsipi_cmd(xs);
1271 #endif
1272
1273 s = splbio();
1274 /*
1275 * The resource this command was using is now free.
1276 */
1277 if (xs->xs_status & XS_STS_DONE) {
1278 /* XXX in certain circumstances, such as a device
1279 * being detached, a xs that has already been
1280 * scsipi_done()'d by the main thread will be done'd
1281 * again by scsibusdetach(). Putting the xs on the
1282 * chan_complete queue causes list corruption and
1283 * everyone dies. This prevents that, but perhaps
1284 * there should be better coordination somewhere such
1285 * that this won't ever happen (and can be turned into
1286 * a KASSERT().
1287 */
1288 splx(s);
1289 goto out;
1290 }
1291 scsipi_put_resource(chan);
1292 xs->xs_periph->periph_sent--;
1293
1294 /*
1295 * If the command was tagged, free the tag.
1296 */
1297 if (XS_CTL_TAGTYPE(xs) != 0)
1298 scsipi_put_tag(xs);
1299 else
1300 periph->periph_flags &= ~PERIPH_UNTAG;
1301
1302 /* Mark the command as `done'. */
1303 xs->xs_status |= XS_STS_DONE;
1304
1305 #ifdef DIAGNOSTIC
1306 if ((xs->xs_control & (XS_CTL_ASYNC|XS_CTL_POLL)) ==
1307 (XS_CTL_ASYNC|XS_CTL_POLL))
1308 panic("scsipi_done: ASYNC and POLL");
1309 #endif
1310
1311 /*
1312 * If the xfer had an error of any sort, freeze the
1313 * periph's queue. Freeze it again if we were requested
1314 * to do so in the xfer.
1315 */
1316 freezecnt = 0;
1317 if (xs->error != XS_NOERROR)
1318 freezecnt++;
1319 if (xs->xs_control & XS_CTL_FREEZE_PERIPH)
1320 freezecnt++;
1321 if (freezecnt != 0)
1322 scsipi_periph_freeze(periph, freezecnt);
1323
1324 /*
1325 * record the xfer with a pending sense, in case a SCSI reset is
1326 * received before the thread is waked up.
1327 */
1328 if (xs->error == XS_BUSY && xs->status == SCSI_CHECK) {
1329 periph->periph_flags |= PERIPH_SENSE;
1330 periph->periph_xscheck = xs;
1331 }
1332
1333 /*
1334 * If this was an xfer that was not to complete asynchronously,
1335 * let the requesting thread perform error checking/handling
1336 * in its context.
1337 */
1338 if ((xs->xs_control & XS_CTL_ASYNC) == 0) {
1339 splx(s);
1340 /*
1341 * If it's a polling job, just return, to unwind the
1342 * call graph. We don't need to restart the queue,
1343 * because pollings jobs are treated specially, and
1344 * are really only used during crash dumps anyway
1345 * (XXX or during boot-time autconfiguration of
1346 * ATAPI devices).
1347 */
1348 if (xs->xs_control & XS_CTL_POLL)
1349 return;
1350 wakeup(xs);
1351 goto out;
1352 }
1353
1354 /*
1355 * Catch the extremely common case of I/O completing
1356 * without error; no use in taking a context switch
1357 * if we can handle it in interrupt context.
1358 */
1359 if (xs->error == XS_NOERROR) {
1360 splx(s);
1361 (void) scsipi_complete(xs);
1362 goto out;
1363 }
1364
1365 /*
1366 * There is an error on this xfer. Put it on the channel's
1367 * completion queue, and wake up the completion thread.
1368 */
1369 TAILQ_INSERT_TAIL(&chan->chan_complete, xs, channel_q);
1370 splx(s);
1371 wakeup(&chan->chan_complete);
1372
1373 out:
1374 /*
1375 * If there are more xfers on the channel's queue, attempt to
1376 * run them.
1377 */
1378 scsipi_run_queue(chan);
1379 }
1380
1381 /*
1382 * scsipi_complete:
1383 *
1384 * Completion of a scsipi_xfer. This is the guts of scsipi_done().
1385 *
1386 * NOTE: This routine MUST be called with valid thread context
1387 * except for the case where the following two conditions are
1388 * true:
1389 *
1390 * xs->error == XS_NOERROR
1391 * XS_CTL_ASYNC is set in xs->xs_control
1392 *
1393 * The semantics of this routine can be tricky, so here is an
1394 * explanation:
1395 *
1396 * 0 Xfer completed successfully.
1397 *
1398 * ERESTART Xfer had an error, but was restarted.
1399 *
1400 * anything else Xfer had an error, return value is Unix
1401 * errno.
1402 *
1403 * If the return value is anything but ERESTART:
1404 *
1405 * - If XS_CTL_ASYNC is set, `xs' has been freed back to
1406 * the pool.
1407 * - If there is a buf associated with the xfer,
1408 * it has been biodone()'d.
1409 */
1410 static int
1411 scsipi_complete(struct scsipi_xfer *xs)
1412 {
1413 struct scsipi_periph *periph = xs->xs_periph;
1414 struct scsipi_channel *chan = periph->periph_channel;
1415 int error, s;
1416
1417 #ifdef DIAGNOSTIC
1418 if ((xs->xs_control & XS_CTL_ASYNC) != 0 && xs->bp == NULL)
1419 panic("scsipi_complete: XS_CTL_ASYNC but no buf");
1420 #endif
1421 /*
1422 * If command terminated with a CHECK CONDITION, we need to issue a
1423 * REQUEST_SENSE command. Once the REQUEST_SENSE has been processed
1424 * we'll have the real status.
1425 * Must be processed at splbio() to avoid missing a SCSI bus reset
1426 * for this command.
1427 */
1428 s = splbio();
1429 if (xs->error == XS_BUSY && xs->status == SCSI_CHECK) {
1430 /* request sense for a request sense ? */
1431 if (xs->xs_control & XS_CTL_REQSENSE) {
1432 scsipi_printaddr(periph);
1433 printf("request sense for a request sense ?\n");
1434 /* XXX maybe we should reset the device ? */
1435 /* we've been frozen because xs->error != XS_NOERROR */
1436 scsipi_periph_thaw(periph, 1);
1437 splx(s);
1438 if (xs->resid < xs->datalen) {
1439 printf("we read %d bytes of sense anyway:\n",
1440 xs->datalen - xs->resid);
1441 #ifdef SCSIVERBOSE
1442 scsipi_print_sense_data((void *)xs->data, 0);
1443 #endif
1444 }
1445 return EINVAL;
1446 }
1447 scsipi_request_sense(xs);
1448 }
1449 splx(s);
1450
1451 /*
1452 * If it's a user level request, bypass all usual completion
1453 * processing, let the user work it out..
1454 */
1455 if ((xs->xs_control & XS_CTL_USERCMD) != 0) {
1456 SC_DEBUG(periph, SCSIPI_DB3, ("calling user done()\n"));
1457 if (xs->error != XS_NOERROR)
1458 scsipi_periph_thaw(periph, 1);
1459 scsipi_user_done(xs);
1460 SC_DEBUG(periph, SCSIPI_DB3, ("returned from user done()\n "));
1461 return 0;
1462 }
1463
1464 switch (xs->error) {
1465 case XS_NOERROR:
1466 error = 0;
1467 break;
1468
1469 case XS_SENSE:
1470 case XS_SHORTSENSE:
1471 error = (*chan->chan_bustype->bustype_interpret_sense)(xs);
1472 break;
1473
1474 case XS_RESOURCE_SHORTAGE:
1475 /*
1476 * XXX Should freeze channel's queue.
1477 */
1478 scsipi_printaddr(periph);
1479 printf("adapter resource shortage\n");
1480 /* FALLTHROUGH */
1481
1482 case XS_BUSY:
1483 if (xs->error == XS_BUSY && xs->status == SCSI_QUEUE_FULL) {
1484 struct scsipi_max_openings mo;
1485
1486 /*
1487 * We set the openings to active - 1, assuming that
1488 * the command that got us here is the first one that
1489 * can't fit into the device's queue. If that's not
1490 * the case, I guess we'll find out soon enough.
1491 */
1492 mo.mo_target = periph->periph_target;
1493 mo.mo_lun = periph->periph_lun;
1494 if (periph->periph_active < periph->periph_openings)
1495 mo.mo_openings = periph->periph_active - 1;
1496 else
1497 mo.mo_openings = periph->periph_openings - 1;
1498 #ifdef DIAGNOSTIC
1499 if (mo.mo_openings < 0) {
1500 scsipi_printaddr(periph);
1501 printf("QUEUE FULL resulted in < 0 openings\n");
1502 panic("scsipi_done");
1503 }
1504 #endif
1505 if (mo.mo_openings == 0) {
1506 scsipi_printaddr(periph);
1507 printf("QUEUE FULL resulted in 0 openings\n");
1508 mo.mo_openings = 1;
1509 }
1510 scsipi_async_event(chan, ASYNC_EVENT_MAX_OPENINGS, &mo);
1511 error = ERESTART;
1512 } else if (xs->xs_retries != 0) {
1513 xs->xs_retries--;
1514 /*
1515 * Wait one second, and try again.
1516 */
1517 if ((xs->xs_control & XS_CTL_POLL) ||
1518 (chan->chan_flags & SCSIPI_CHAN_TACTIVE) == 0) {
1519 delay(1000000);
1520 } else if (!callout_pending(&periph->periph_callout)) {
1521 scsipi_periph_freeze(periph, 1);
1522 callout_reset(&periph->periph_callout,
1523 hz, scsipi_periph_timed_thaw, periph);
1524 }
1525 error = ERESTART;
1526 } else
1527 error = EBUSY;
1528 break;
1529
1530 case XS_REQUEUE:
1531 error = ERESTART;
1532 break;
1533
1534 case XS_SELTIMEOUT:
1535 case XS_TIMEOUT:
1536 /*
1537 * If the device hasn't gone away, honor retry counts.
1538 *
1539 * Note that if we're in the middle of probing it,
1540 * it won't be found because it isn't here yet so
1541 * we won't honor the retry count in that case.
1542 */
1543 if (scsipi_lookup_periph(chan, periph->periph_target,
1544 periph->periph_lun) && xs->xs_retries != 0) {
1545 xs->xs_retries--;
1546 error = ERESTART;
1547 } else
1548 error = EIO;
1549 break;
1550
1551 case XS_RESET:
1552 if (xs->xs_control & XS_CTL_REQSENSE) {
1553 /*
1554 * request sense interrupted by reset: signal it
1555 * with EINTR return code.
1556 */
1557 error = EINTR;
1558 } else {
1559 if (xs->xs_retries != 0) {
1560 xs->xs_retries--;
1561 error = ERESTART;
1562 } else
1563 error = EIO;
1564 }
1565 break;
1566
1567 case XS_DRIVER_STUFFUP:
1568 scsipi_printaddr(periph);
1569 printf("generic HBA error\n");
1570 error = EIO;
1571 break;
1572 default:
1573 scsipi_printaddr(periph);
1574 printf("invalid return code from adapter: %d\n", xs->error);
1575 error = EIO;
1576 break;
1577 }
1578
1579 s = splbio();
1580 if (error == ERESTART) {
1581 /*
1582 * If we get here, the periph has been thawed and frozen
1583 * again if we had to issue recovery commands. Alternatively,
1584 * it may have been frozen again and in a timed thaw. In
1585 * any case, we thaw the periph once we re-enqueue the
1586 * command. Once the periph is fully thawed, it will begin
1587 * operation again.
1588 */
1589 xs->error = XS_NOERROR;
1590 xs->status = SCSI_OK;
1591 xs->xs_status &= ~XS_STS_DONE;
1592 xs->xs_requeuecnt++;
1593 error = scsipi_enqueue(xs);
1594 if (error == 0) {
1595 scsipi_periph_thaw(periph, 1);
1596 splx(s);
1597 return (ERESTART);
1598 }
1599 }
1600
1601 /*
1602 * scsipi_done() freezes the queue if not XS_NOERROR.
1603 * Thaw it here.
1604 */
1605 if (xs->error != XS_NOERROR)
1606 scsipi_periph_thaw(periph, 1);
1607
1608 if (periph->periph_switch->psw_done)
1609 periph->periph_switch->psw_done(xs, error);
1610
1611 if (xs->xs_control & XS_CTL_ASYNC)
1612 scsipi_put_xs(xs);
1613 splx(s);
1614
1615 return (error);
1616 }
1617
1618 /*
1619 * Issue a request sense for the given scsipi_xfer. Called when the xfer
1620 * returns with a CHECK_CONDITION status. Must be called in valid thread
1621 * context and at splbio().
1622 */
1623
1624 static void
1625 scsipi_request_sense(struct scsipi_xfer *xs)
1626 {
1627 struct scsipi_periph *periph = xs->xs_periph;
1628 int flags, error;
1629 struct scsi_request_sense cmd;
1630
1631 periph->periph_flags |= PERIPH_SENSE;
1632
1633 /* if command was polling, request sense will too */
1634 flags = xs->xs_control & XS_CTL_POLL;
1635 /* Polling commands can't sleep */
1636 if (flags)
1637 flags |= XS_CTL_NOSLEEP;
1638
1639 flags |= XS_CTL_REQSENSE | XS_CTL_URGENT | XS_CTL_DATA_IN |
1640 XS_CTL_THAW_PERIPH | XS_CTL_FREEZE_PERIPH;
1641
1642 memset(&cmd, 0, sizeof(cmd));
1643 cmd.opcode = SCSI_REQUEST_SENSE;
1644 cmd.length = sizeof(struct scsi_sense_data);
1645
1646 error = scsipi_command(periph, (void *)&cmd, sizeof(cmd),
1647 (void *)&xs->sense.scsi_sense, sizeof(struct scsi_sense_data),
1648 0, 1000, NULL, flags);
1649 periph->periph_flags &= ~PERIPH_SENSE;
1650 periph->periph_xscheck = NULL;
1651 switch (error) {
1652 case 0:
1653 /* we have a valid sense */
1654 xs->error = XS_SENSE;
1655 return;
1656 case EINTR:
1657 /* REQUEST_SENSE interrupted by bus reset. */
1658 xs->error = XS_RESET;
1659 return;
1660 case EIO:
1661 /* request sense coudn't be performed */
1662 /*
1663 * XXX this isn't quite right but we don't have anything
1664 * better for now
1665 */
1666 xs->error = XS_DRIVER_STUFFUP;
1667 return;
1668 default:
1669 /* Notify that request sense failed. */
1670 xs->error = XS_DRIVER_STUFFUP;
1671 scsipi_printaddr(periph);
1672 printf("request sense failed with error %d\n", error);
1673 return;
1674 }
1675 }
1676
1677 /*
1678 * scsipi_enqueue:
1679 *
1680 * Enqueue an xfer on a channel.
1681 */
1682 static int
1683 scsipi_enqueue(struct scsipi_xfer *xs)
1684 {
1685 struct scsipi_channel *chan = xs->xs_periph->periph_channel;
1686 struct scsipi_xfer *qxs;
1687 int s;
1688
1689 s = splbio();
1690
1691 /*
1692 * If the xfer is to be polled, and there are already jobs on
1693 * the queue, we can't proceed.
1694 */
1695 if ((xs->xs_control & XS_CTL_POLL) != 0 &&
1696 TAILQ_FIRST(&chan->chan_queue) != NULL) {
1697 splx(s);
1698 xs->error = XS_DRIVER_STUFFUP;
1699 return (EAGAIN);
1700 }
1701
1702 /*
1703 * If we have an URGENT xfer, it's an error recovery command
1704 * and it should just go on the head of the channel's queue.
1705 */
1706 if (xs->xs_control & XS_CTL_URGENT) {
1707 TAILQ_INSERT_HEAD(&chan->chan_queue, xs, channel_q);
1708 goto out;
1709 }
1710
1711 /*
1712 * If this xfer has already been on the queue before, we
1713 * need to reinsert it in the correct order. That order is:
1714 *
1715 * Immediately before the first xfer for this periph
1716 * with a requeuecnt less than xs->xs_requeuecnt.
1717 *
1718 * Failing that, at the end of the queue. (We'll end up
1719 * there naturally.)
1720 */
1721 if (xs->xs_requeuecnt != 0) {
1722 for (qxs = TAILQ_FIRST(&chan->chan_queue); qxs != NULL;
1723 qxs = TAILQ_NEXT(qxs, channel_q)) {
1724 if (qxs->xs_periph == xs->xs_periph &&
1725 qxs->xs_requeuecnt < xs->xs_requeuecnt)
1726 break;
1727 }
1728 if (qxs != NULL) {
1729 TAILQ_INSERT_AFTER(&chan->chan_queue, qxs, xs,
1730 channel_q);
1731 goto out;
1732 }
1733 }
1734 TAILQ_INSERT_TAIL(&chan->chan_queue, xs, channel_q);
1735 out:
1736 if (xs->xs_control & XS_CTL_THAW_PERIPH)
1737 scsipi_periph_thaw(xs->xs_periph, 1);
1738 splx(s);
1739 return (0);
1740 }
1741
1742 /*
1743 * scsipi_run_queue:
1744 *
1745 * Start as many xfers as possible running on the channel.
1746 */
1747 static void
1748 scsipi_run_queue(struct scsipi_channel *chan)
1749 {
1750 struct scsipi_xfer *xs;
1751 struct scsipi_periph *periph;
1752 int s;
1753
1754 for (;;) {
1755 s = splbio();
1756
1757 /*
1758 * If the channel is frozen, we can't do any work right
1759 * now.
1760 */
1761 if (chan->chan_qfreeze != 0) {
1762 splx(s);
1763 return;
1764 }
1765
1766 /*
1767 * Look for work to do, and make sure we can do it.
1768 */
1769 for (xs = TAILQ_FIRST(&chan->chan_queue); xs != NULL;
1770 xs = TAILQ_NEXT(xs, channel_q)) {
1771 periph = xs->xs_periph;
1772
1773 if ((periph->periph_sent >= periph->periph_openings) ||
1774 periph->periph_qfreeze != 0 ||
1775 (periph->periph_flags & PERIPH_UNTAG) != 0)
1776 continue;
1777
1778 if ((periph->periph_flags &
1779 (PERIPH_RECOVERING | PERIPH_SENSE)) != 0 &&
1780 (xs->xs_control & XS_CTL_URGENT) == 0)
1781 continue;
1782
1783 /*
1784 * We can issue this xfer!
1785 */
1786 goto got_one;
1787 }
1788
1789 /*
1790 * Can't find any work to do right now.
1791 */
1792 splx(s);
1793 return;
1794
1795 got_one:
1796 /*
1797 * Have an xfer to run. Allocate a resource from
1798 * the adapter to run it. If we can't allocate that
1799 * resource, we don't dequeue the xfer.
1800 */
1801 if (scsipi_get_resource(chan) == 0) {
1802 /*
1803 * Adapter is out of resources. If the adapter
1804 * supports it, attempt to grow them.
1805 */
1806 if (scsipi_grow_resources(chan) == 0) {
1807 /*
1808 * Wasn't able to grow resources,
1809 * nothing more we can do.
1810 */
1811 if (xs->xs_control & XS_CTL_POLL) {
1812 scsipi_printaddr(xs->xs_periph);
1813 printf("polling command but no "
1814 "adapter resources");
1815 /* We'll panic shortly... */
1816 }
1817 splx(s);
1818
1819 /*
1820 * XXX: We should be able to note that
1821 * XXX: that resources are needed here!
1822 */
1823 return;
1824 }
1825 /*
1826 * scsipi_grow_resources() allocated the resource
1827 * for us.
1828 */
1829 }
1830
1831 /*
1832 * We have a resource to run this xfer, do it!
1833 */
1834 TAILQ_REMOVE(&chan->chan_queue, xs, channel_q);
1835
1836 /*
1837 * If the command is to be tagged, allocate a tag ID
1838 * for it.
1839 */
1840 if (XS_CTL_TAGTYPE(xs) != 0)
1841 scsipi_get_tag(xs);
1842 else
1843 periph->periph_flags |= PERIPH_UNTAG;
1844 periph->periph_sent++;
1845 splx(s);
1846
1847 scsipi_adapter_request(chan, ADAPTER_REQ_RUN_XFER, xs);
1848 }
1849 #ifdef DIAGNOSTIC
1850 panic("scsipi_run_queue: impossible");
1851 #endif
1852 }
1853
1854 /*
1855 * scsipi_execute_xs:
1856 *
1857 * Begin execution of an xfer, waiting for it to complete, if necessary.
1858 */
1859 int
1860 scsipi_execute_xs(struct scsipi_xfer *xs)
1861 {
1862 struct scsipi_periph *periph = xs->xs_periph;
1863 struct scsipi_channel *chan = periph->periph_channel;
1864 int oasync, async, poll, error, s;
1865
1866 KASSERT(!cold);
1867
1868 (chan->chan_bustype->bustype_cmd)(xs);
1869
1870 if (xs->xs_control & XS_CTL_DATA_ONSTACK) {
1871 #if 1
1872 if (xs->xs_control & XS_CTL_ASYNC)
1873 panic("scsipi_execute_xs: on stack and async");
1874 #endif
1875 /*
1876 * If the I/O buffer is allocated on stack, the
1877 * process must NOT be swapped out, as the device will
1878 * be accessing the stack.
1879 */
1880 uvm_lwp_hold(curlwp);
1881 }
1882
1883 xs->xs_status &= ~XS_STS_DONE;
1884 xs->error = XS_NOERROR;
1885 xs->resid = xs->datalen;
1886 xs->status = SCSI_OK;
1887
1888 #ifdef SCSIPI_DEBUG
1889 if (xs->xs_periph->periph_dbflags & SCSIPI_DB3) {
1890 printf("scsipi_execute_xs: ");
1891 show_scsipi_xs(xs);
1892 printf("\n");
1893 }
1894 #endif
1895
1896 /*
1897 * Deal with command tagging:
1898 *
1899 * - If the device's current operating mode doesn't
1900 * include tagged queueing, clear the tag mask.
1901 *
1902 * - If the device's current operating mode *does*
1903 * include tagged queueing, set the tag_type in
1904 * the xfer to the appropriate byte for the tag
1905 * message.
1906 */
1907 if ((PERIPH_XFER_MODE(periph) & PERIPH_CAP_TQING) == 0 ||
1908 (xs->xs_control & XS_CTL_REQSENSE)) {
1909 xs->xs_control &= ~XS_CTL_TAGMASK;
1910 xs->xs_tag_type = 0;
1911 } else {
1912 /*
1913 * If the request doesn't specify a tag, give Head
1914 * tags to URGENT operations and Ordered tags to
1915 * everything else.
1916 */
1917 if (XS_CTL_TAGTYPE(xs) == 0) {
1918 if (xs->xs_control & XS_CTL_URGENT)
1919 xs->xs_control |= XS_CTL_HEAD_TAG;
1920 else
1921 xs->xs_control |= XS_CTL_ORDERED_TAG;
1922 }
1923
1924 switch (XS_CTL_TAGTYPE(xs)) {
1925 case XS_CTL_ORDERED_TAG:
1926 xs->xs_tag_type = MSG_ORDERED_Q_TAG;
1927 break;
1928
1929 case XS_CTL_SIMPLE_TAG:
1930 xs->xs_tag_type = MSG_SIMPLE_Q_TAG;
1931 break;
1932
1933 case XS_CTL_HEAD_TAG:
1934 xs->xs_tag_type = MSG_HEAD_OF_Q_TAG;
1935 break;
1936
1937 default:
1938 scsipi_printaddr(periph);
1939 printf("invalid tag mask 0x%08x\n",
1940 XS_CTL_TAGTYPE(xs));
1941 panic("scsipi_execute_xs");
1942 }
1943 }
1944
1945 /* If the adaptor wants us to poll, poll. */
1946 if (chan->chan_adapter->adapt_flags & SCSIPI_ADAPT_POLL_ONLY)
1947 xs->xs_control |= XS_CTL_POLL;
1948
1949 /*
1950 * If we don't yet have a completion thread, or we are to poll for
1951 * completion, clear the ASYNC flag.
1952 */
1953 oasync = (xs->xs_control & XS_CTL_ASYNC);
1954 if (chan->chan_thread == NULL || (xs->xs_control & XS_CTL_POLL) != 0)
1955 xs->xs_control &= ~XS_CTL_ASYNC;
1956
1957 async = (xs->xs_control & XS_CTL_ASYNC);
1958 poll = (xs->xs_control & XS_CTL_POLL);
1959
1960 #ifdef DIAGNOSTIC
1961 if (oasync != 0 && xs->bp == NULL)
1962 panic("scsipi_execute_xs: XS_CTL_ASYNC but no buf");
1963 #endif
1964
1965 /*
1966 * Enqueue the transfer. If we're not polling for completion, this
1967 * should ALWAYS return `no error'.
1968 */
1969 error = scsipi_enqueue(xs);
1970 if (error) {
1971 if (poll == 0) {
1972 scsipi_printaddr(periph);
1973 printf("not polling, but enqueue failed with %d\n",
1974 error);
1975 panic("scsipi_execute_xs");
1976 }
1977
1978 scsipi_printaddr(periph);
1979 printf("should have flushed queue?\n");
1980 goto free_xs;
1981 }
1982
1983 restarted:
1984 scsipi_run_queue(chan);
1985
1986 /*
1987 * The xfer is enqueued, and possibly running. If it's to be
1988 * completed asynchronously, just return now.
1989 */
1990 if (async)
1991 return (0);
1992
1993 /*
1994 * Not an asynchronous command; wait for it to complete.
1995 */
1996 s = splbio();
1997 while ((xs->xs_status & XS_STS_DONE) == 0) {
1998 if (poll) {
1999 scsipi_printaddr(periph);
2000 printf("polling command not done\n");
2001 panic("scsipi_execute_xs");
2002 }
2003 (void) tsleep(xs, PRIBIO, "xscmd", 0);
2004 }
2005 splx(s);
2006
2007 /*
2008 * Command is complete. scsipi_done() has awakened us to perform
2009 * the error handling.
2010 */
2011 error = scsipi_complete(xs);
2012 if (error == ERESTART)
2013 goto restarted;
2014
2015 /*
2016 * If it was meant to run async and we cleared aync ourselve,
2017 * don't return an error here. It has already been handled
2018 */
2019 if (oasync)
2020 error = 0;
2021 /*
2022 * Command completed successfully or fatal error occurred. Fall
2023 * into....
2024 */
2025 free_xs:
2026 if (xs->xs_control & XS_CTL_DATA_ONSTACK)
2027 uvm_lwp_rele(curlwp);
2028
2029 s = splbio();
2030 scsipi_put_xs(xs);
2031 splx(s);
2032
2033 /*
2034 * Kick the queue, keep it running in case it stopped for some
2035 * reason.
2036 */
2037 scsipi_run_queue(chan);
2038
2039 return (error);
2040 }
2041
2042 /*
2043 * scsipi_completion_thread:
2044 *
2045 * This is the completion thread. We wait for errors on
2046 * asynchronous xfers, and perform the error handling
2047 * function, restarting the command, if necessary.
2048 */
2049 static void
2050 scsipi_completion_thread(void *arg)
2051 {
2052 struct scsipi_channel *chan = arg;
2053 struct scsipi_xfer *xs;
2054 int s;
2055
2056 if (chan->chan_init_cb)
2057 (*chan->chan_init_cb)(chan, chan->chan_init_cb_arg);
2058
2059 s = splbio();
2060 chan->chan_flags |= SCSIPI_CHAN_TACTIVE;
2061 splx(s);
2062 for (;;) {
2063 s = splbio();
2064 xs = TAILQ_FIRST(&chan->chan_complete);
2065 if (xs == NULL && chan->chan_tflags == 0) {
2066 /* nothing to do; wait */
2067 (void) tsleep(&chan->chan_complete, PRIBIO,
2068 "sccomp", 0);
2069 splx(s);
2070 continue;
2071 }
2072 if (chan->chan_tflags & SCSIPI_CHANT_CALLBACK) {
2073 /* call chan_callback from thread context */
2074 chan->chan_tflags &= ~SCSIPI_CHANT_CALLBACK;
2075 chan->chan_callback(chan, chan->chan_callback_arg);
2076 splx(s);
2077 continue;
2078 }
2079 if (chan->chan_tflags & SCSIPI_CHANT_GROWRES) {
2080 /* attempt to get more openings for this channel */
2081 chan->chan_tflags &= ~SCSIPI_CHANT_GROWRES;
2082 scsipi_adapter_request(chan,
2083 ADAPTER_REQ_GROW_RESOURCES, NULL);
2084 scsipi_channel_thaw(chan, 1);
2085 splx(s);
2086 if (chan->chan_tflags & SCSIPI_CHANT_GROWRES)
2087 kpause("scsizzz", FALSE, hz/10, NULL);
2088 continue;
2089 }
2090 if (chan->chan_tflags & SCSIPI_CHANT_KICK) {
2091 /* explicitly run the queues for this channel */
2092 chan->chan_tflags &= ~SCSIPI_CHANT_KICK;
2093 scsipi_run_queue(chan);
2094 splx(s);
2095 continue;
2096 }
2097 if (chan->chan_tflags & SCSIPI_CHANT_SHUTDOWN) {
2098 splx(s);
2099 break;
2100 }
2101 if (xs) {
2102 TAILQ_REMOVE(&chan->chan_complete, xs, channel_q);
2103 splx(s);
2104
2105 /*
2106 * Have an xfer with an error; process it.
2107 */
2108 (void) scsipi_complete(xs);
2109
2110 /*
2111 * Kick the queue; keep it running if it was stopped
2112 * for some reason.
2113 */
2114 scsipi_run_queue(chan);
2115 } else {
2116 splx(s);
2117 }
2118 }
2119
2120 chan->chan_thread = NULL;
2121
2122 /* In case parent is waiting for us to exit. */
2123 wakeup(&chan->chan_thread);
2124
2125 kthread_exit(0);
2126 }
2127 /*
2128 * scsipi_thread_call_callback:
2129 *
2130 * request to call a callback from the completion thread
2131 */
2132 int
2133 scsipi_thread_call_callback(struct scsipi_channel *chan,
2134 void (*callback)(struct scsipi_channel *, void *), void *arg)
2135 {
2136 int s;
2137
2138 s = splbio();
2139 if ((chan->chan_flags & SCSIPI_CHAN_TACTIVE) == 0) {
2140 /* kernel thread doesn't exist yet */
2141 splx(s);
2142 return ESRCH;
2143 }
2144 if (chan->chan_tflags & SCSIPI_CHANT_CALLBACK) {
2145 splx(s);
2146 return EBUSY;
2147 }
2148 scsipi_channel_freeze(chan, 1);
2149 chan->chan_callback = callback;
2150 chan->chan_callback_arg = arg;
2151 chan->chan_tflags |= SCSIPI_CHANT_CALLBACK;
2152 wakeup(&chan->chan_complete);
2153 splx(s);
2154 return(0);
2155 }
2156
2157 /*
2158 * scsipi_async_event:
2159 *
2160 * Handle an asynchronous event from an adapter.
2161 */
2162 void
2163 scsipi_async_event(struct scsipi_channel *chan, scsipi_async_event_t event,
2164 void *arg)
2165 {
2166 int s;
2167
2168 s = splbio();
2169 switch (event) {
2170 case ASYNC_EVENT_MAX_OPENINGS:
2171 scsipi_async_event_max_openings(chan,
2172 (struct scsipi_max_openings *)arg);
2173 break;
2174
2175 case ASYNC_EVENT_XFER_MODE:
2176 scsipi_async_event_xfer_mode(chan,
2177 (struct scsipi_xfer_mode *)arg);
2178 break;
2179 case ASYNC_EVENT_RESET:
2180 scsipi_async_event_channel_reset(chan);
2181 break;
2182 }
2183 splx(s);
2184 }
2185
2186 /*
2187 * scsipi_print_xfer_mode:
2188 *
2189 * Print a periph's capabilities.
2190 */
2191 void
2192 scsipi_print_xfer_mode(struct scsipi_periph *periph)
2193 {
2194 int period, freq, speed, mbs;
2195
2196 if ((periph->periph_flags & PERIPH_MODE_VALID) == 0)
2197 return;
2198
2199 aprint_normal_dev(periph->periph_dev, "");
2200 if (periph->periph_mode & (PERIPH_CAP_SYNC | PERIPH_CAP_DT)) {
2201 period = scsipi_sync_factor_to_period(periph->periph_period);
2202 aprint_normal("sync (%d.%02dns offset %d)",
2203 period / 100, period % 100, periph->periph_offset);
2204 } else
2205 aprint_normal("async");
2206
2207 if (periph->periph_mode & PERIPH_CAP_WIDE32)
2208 aprint_normal(", 32-bit");
2209 else if (periph->periph_mode & (PERIPH_CAP_WIDE16 | PERIPH_CAP_DT))
2210 aprint_normal(", 16-bit");
2211 else
2212 aprint_normal(", 8-bit");
2213
2214 if (periph->periph_mode & (PERIPH_CAP_SYNC | PERIPH_CAP_DT)) {
2215 freq = scsipi_sync_factor_to_freq(periph->periph_period);
2216 speed = freq;
2217 if (periph->periph_mode & PERIPH_CAP_WIDE32)
2218 speed *= 4;
2219 else if (periph->periph_mode &
2220 (PERIPH_CAP_WIDE16 | PERIPH_CAP_DT))
2221 speed *= 2;
2222 mbs = speed / 1000;
2223 if (mbs > 0)
2224 aprint_normal(" (%d.%03dMB/s)", mbs, speed % 1000);
2225 else
2226 aprint_normal(" (%dKB/s)", speed % 1000);
2227 }
2228
2229 aprint_normal(" transfers");
2230
2231 if (periph->periph_mode & PERIPH_CAP_TQING)
2232 aprint_normal(", tagged queueing");
2233
2234 aprint_normal("\n");
2235 }
2236
2237 /*
2238 * scsipi_async_event_max_openings:
2239 *
2240 * Update the maximum number of outstanding commands a
2241 * device may have.
2242 */
2243 static void
2244 scsipi_async_event_max_openings(struct scsipi_channel *chan,
2245 struct scsipi_max_openings *mo)
2246 {
2247 struct scsipi_periph *periph;
2248 int minlun, maxlun;
2249
2250 if (mo->mo_lun == -1) {
2251 /*
2252 * Wildcarded; apply it to all LUNs.
2253 */
2254 minlun = 0;
2255 maxlun = chan->chan_nluns - 1;
2256 } else
2257 minlun = maxlun = mo->mo_lun;
2258
2259 /* XXX This could really suck with a large LUN space. */
2260 for (; minlun <= maxlun; minlun++) {
2261 periph = scsipi_lookup_periph(chan, mo->mo_target, minlun);
2262 if (periph == NULL)
2263 continue;
2264
2265 if (mo->mo_openings < periph->periph_openings)
2266 periph->periph_openings = mo->mo_openings;
2267 else if (mo->mo_openings > periph->periph_openings &&
2268 (periph->periph_flags & PERIPH_GROW_OPENINGS) != 0)
2269 periph->periph_openings = mo->mo_openings;
2270 }
2271 }
2272
2273 /*
2274 * scsipi_async_event_xfer_mode:
2275 *
2276 * Update the xfer mode for all periphs sharing the
2277 * specified I_T Nexus.
2278 */
2279 static void
2280 scsipi_async_event_xfer_mode(struct scsipi_channel *chan,
2281 struct scsipi_xfer_mode *xm)
2282 {
2283 struct scsipi_periph *periph;
2284 int lun, announce, mode, period, offset;
2285
2286 for (lun = 0; lun < chan->chan_nluns; lun++) {
2287 periph = scsipi_lookup_periph(chan, xm->xm_target, lun);
2288 if (periph == NULL)
2289 continue;
2290 announce = 0;
2291
2292 /*
2293 * Clamp the xfer mode down to this periph's capabilities.
2294 */
2295 mode = xm->xm_mode & periph->periph_cap;
2296 if (mode & PERIPH_CAP_SYNC) {
2297 period = xm->xm_period;
2298 offset = xm->xm_offset;
2299 } else {
2300 period = 0;
2301 offset = 0;
2302 }
2303
2304 /*
2305 * If we do not have a valid xfer mode yet, or the parameters
2306 * are different, announce them.
2307 */
2308 if ((periph->periph_flags & PERIPH_MODE_VALID) == 0 ||
2309 periph->periph_mode != mode ||
2310 periph->periph_period != period ||
2311 periph->periph_offset != offset)
2312 announce = 1;
2313
2314 periph->periph_mode = mode;
2315 periph->periph_period = period;
2316 periph->periph_offset = offset;
2317 periph->periph_flags |= PERIPH_MODE_VALID;
2318
2319 if (announce)
2320 scsipi_print_xfer_mode(periph);
2321 }
2322 }
2323
2324 /*
2325 * scsipi_set_xfer_mode:
2326 *
2327 * Set the xfer mode for the specified I_T Nexus.
2328 */
2329 void
2330 scsipi_set_xfer_mode(struct scsipi_channel *chan, int target, int immed)
2331 {
2332 struct scsipi_xfer_mode xm;
2333 struct scsipi_periph *itperiph;
2334 int lun, s;
2335
2336 /*
2337 * Go to the minimal xfer mode.
2338 */
2339 xm.xm_target = target;
2340 xm.xm_mode = 0;
2341 xm.xm_period = 0; /* ignored */
2342 xm.xm_offset = 0; /* ignored */
2343
2344 /*
2345 * Find the first LUN we know about on this I_T Nexus.
2346 */
2347 for (itperiph = NULL, lun = 0; lun < chan->chan_nluns; lun++) {
2348 itperiph = scsipi_lookup_periph(chan, target, lun);
2349 if (itperiph != NULL)
2350 break;
2351 }
2352 if (itperiph != NULL) {
2353 xm.xm_mode = itperiph->periph_cap;
2354 /*
2355 * Now issue the request to the adapter.
2356 */
2357 s = splbio();
2358 scsipi_adapter_request(chan, ADAPTER_REQ_SET_XFER_MODE, &xm);
2359 splx(s);
2360 /*
2361 * If we want this to happen immediately, issue a dummy
2362 * command, since most adapters can't really negotiate unless
2363 * they're executing a job.
2364 */
2365 if (immed != 0) {
2366 (void) scsipi_test_unit_ready(itperiph,
2367 XS_CTL_DISCOVERY | XS_CTL_IGNORE_ILLEGAL_REQUEST |
2368 XS_CTL_IGNORE_NOT_READY |
2369 XS_CTL_IGNORE_MEDIA_CHANGE);
2370 }
2371 }
2372 }
2373
2374 /*
2375 * scsipi_channel_reset:
2376 *
2377 * handle scsi bus reset
2378 * called at splbio
2379 */
2380 static void
2381 scsipi_async_event_channel_reset(struct scsipi_channel *chan)
2382 {
2383 struct scsipi_xfer *xs, *xs_next;
2384 struct scsipi_periph *periph;
2385 int target, lun;
2386
2387 /*
2388 * Channel has been reset. Also mark as reset pending REQUEST_SENSE
2389 * commands; as the sense is not available any more.
2390 * can't call scsipi_done() from here, as the command has not been
2391 * sent to the adapter yet (this would corrupt accounting).
2392 */
2393
2394 for (xs = TAILQ_FIRST(&chan->chan_queue); xs != NULL; xs = xs_next) {
2395 xs_next = TAILQ_NEXT(xs, channel_q);
2396 if (xs->xs_control & XS_CTL_REQSENSE) {
2397 TAILQ_REMOVE(&chan->chan_queue, xs, channel_q);
2398 xs->error = XS_RESET;
2399 if ((xs->xs_control & XS_CTL_ASYNC) != 0)
2400 TAILQ_INSERT_TAIL(&chan->chan_complete, xs,
2401 channel_q);
2402 }
2403 }
2404 wakeup(&chan->chan_complete);
2405 /* Catch xs with pending sense which may not have a REQSENSE xs yet */
2406 for (target = 0; target < chan->chan_ntargets; target++) {
2407 if (target == chan->chan_id)
2408 continue;
2409 for (lun = 0; lun < chan->chan_nluns; lun++) {
2410 periph = scsipi_lookup_periph(chan, target, lun);
2411 if (periph) {
2412 xs = periph->periph_xscheck;
2413 if (xs)
2414 xs->error = XS_RESET;
2415 }
2416 }
2417 }
2418 }
2419
2420 /*
2421 * scsipi_target_detach:
2422 *
2423 * detach all periph associated with a I_T
2424 * must be called from valid thread context
2425 */
2426 int
2427 scsipi_target_detach(struct scsipi_channel *chan, int target, int lun,
2428 int flags)
2429 {
2430 struct scsipi_periph *periph;
2431 int ctarget, mintarget, maxtarget;
2432 int clun, minlun, maxlun;
2433 int error;
2434
2435 if (target == -1) {
2436 mintarget = 0;
2437 maxtarget = chan->chan_ntargets;
2438 } else {
2439 if (target == chan->chan_id)
2440 return EINVAL;
2441 if (target < 0 || target >= chan->chan_ntargets)
2442 return EINVAL;
2443 mintarget = target;
2444 maxtarget = target + 1;
2445 }
2446
2447 if (lun == -1) {
2448 minlun = 0;
2449 maxlun = chan->chan_nluns;
2450 } else {
2451 if (lun < 0 || lun >= chan->chan_nluns)
2452 return EINVAL;
2453 minlun = lun;
2454 maxlun = lun + 1;
2455 }
2456
2457 for (ctarget = mintarget; ctarget < maxtarget; ctarget++) {
2458 if (ctarget == chan->chan_id)
2459 continue;
2460
2461 for (clun = minlun; clun < maxlun; clun++) {
2462 periph = scsipi_lookup_periph(chan, ctarget, clun);
2463 if (periph == NULL)
2464 continue;
2465 error = config_detach(periph->periph_dev, flags);
2466 if (error)
2467 return (error);
2468 }
2469 }
2470 return(0);
2471 }
2472
2473 /*
2474 * scsipi_adapter_addref:
2475 *
2476 * Add a reference to the adapter pointed to by the provided
2477 * link, enabling the adapter if necessary.
2478 */
2479 int
2480 scsipi_adapter_addref(struct scsipi_adapter *adapt)
2481 {
2482 int s, error = 0;
2483
2484 s = splbio();
2485 if (adapt->adapt_refcnt++ == 0 && adapt->adapt_enable != NULL) {
2486 error = (*adapt->adapt_enable)(adapt->adapt_dev, 1);
2487 if (error)
2488 adapt->adapt_refcnt--;
2489 }
2490 splx(s);
2491 return (error);
2492 }
2493
2494 /*
2495 * scsipi_adapter_delref:
2496 *
2497 * Delete a reference to the adapter pointed to by the provided
2498 * link, disabling the adapter if possible.
2499 */
2500 void
2501 scsipi_adapter_delref(struct scsipi_adapter *adapt)
2502 {
2503 int s;
2504
2505 s = splbio();
2506 if (adapt->adapt_refcnt-- == 1 && adapt->adapt_enable != NULL)
2507 (void) (*adapt->adapt_enable)(adapt->adapt_dev, 0);
2508 splx(s);
2509 }
2510
2511 static struct scsipi_syncparam {
2512 int ss_factor;
2513 int ss_period; /* ns * 100 */
2514 } scsipi_syncparams[] = {
2515 { 0x08, 625 }, /* FAST-160 (Ultra320) */
2516 { 0x09, 1250 }, /* FAST-80 (Ultra160) */
2517 { 0x0a, 2500 }, /* FAST-40 40MHz (Ultra2) */
2518 { 0x0b, 3030 }, /* FAST-40 33MHz (Ultra2) */
2519 { 0x0c, 5000 }, /* FAST-20 (Ultra) */
2520 };
2521 static const int scsipi_nsyncparams =
2522 sizeof(scsipi_syncparams) / sizeof(scsipi_syncparams[0]);
2523
2524 int
2525 scsipi_sync_period_to_factor(int period /* ns * 100 */)
2526 {
2527 int i;
2528
2529 for (i = 0; i < scsipi_nsyncparams; i++) {
2530 if (period <= scsipi_syncparams[i].ss_period)
2531 return (scsipi_syncparams[i].ss_factor);
2532 }
2533
2534 return ((period / 100) / 4);
2535 }
2536
2537 int
2538 scsipi_sync_factor_to_period(int factor)
2539 {
2540 int i;
2541
2542 for (i = 0; i < scsipi_nsyncparams; i++) {
2543 if (factor == scsipi_syncparams[i].ss_factor)
2544 return (scsipi_syncparams[i].ss_period);
2545 }
2546
2547 return ((factor * 4) * 100);
2548 }
2549
2550 int
2551 scsipi_sync_factor_to_freq(int factor)
2552 {
2553 int i;
2554
2555 for (i = 0; i < scsipi_nsyncparams; i++) {
2556 if (factor == scsipi_syncparams[i].ss_factor)
2557 return (100000000 / scsipi_syncparams[i].ss_period);
2558 }
2559
2560 return (10000000 / ((factor * 4) * 10));
2561 }
2562
2563 #ifdef SCSIPI_DEBUG
2564 /*
2565 * Given a scsipi_xfer, dump the request, in all it's glory
2566 */
2567 void
2568 show_scsipi_xs(struct scsipi_xfer *xs)
2569 {
2570
2571 printf("xs(%p): ", xs);
2572 printf("xs_control(0x%08x)", xs->xs_control);
2573 printf("xs_status(0x%08x)", xs->xs_status);
2574 printf("periph(%p)", xs->xs_periph);
2575 printf("retr(0x%x)", xs->xs_retries);
2576 printf("timo(0x%x)", xs->timeout);
2577 printf("cmd(%p)", xs->cmd);
2578 printf("len(0x%x)", xs->cmdlen);
2579 printf("data(%p)", xs->data);
2580 printf("len(0x%x)", xs->datalen);
2581 printf("res(0x%x)", xs->resid);
2582 printf("err(0x%x)", xs->error);
2583 printf("bp(%p)", xs->bp);
2584 show_scsipi_cmd(xs);
2585 }
2586
2587 void
2588 show_scsipi_cmd(struct scsipi_xfer *xs)
2589 {
2590 u_char *b = (u_char *) xs->cmd;
2591 int i = 0;
2592
2593 scsipi_printaddr(xs->xs_periph);
2594 printf(" command: ");
2595
2596 if ((xs->xs_control & XS_CTL_RESET) == 0) {
2597 while (i < xs->cmdlen) {
2598 if (i)
2599 printf(",");
2600 printf("0x%x", b[i++]);
2601 }
2602 printf("-[%d bytes]\n", xs->datalen);
2603 if (xs->datalen)
2604 show_mem(xs->data, min(64, xs->datalen));
2605 } else
2606 printf("-RESET-\n");
2607 }
2608
2609 void
2610 show_mem(u_char *address, int num)
2611 {
2612 int x;
2613
2614 printf("------------------------------");
2615 for (x = 0; x < num; x++) {
2616 if ((x % 16) == 0)
2617 printf("\n%03d: ", x);
2618 printf("%02x ", *address++);
2619 }
2620 printf("\n------------------------------\n");
2621 }
2622 #endif /* SCSIPI_DEBUG */
Cache object: 143ed0241d2e8278d2795bbd0bc87526
|