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