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