Home | History | Annotate | Line # | Download | only in scsipi
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