Home | History | Annotate | Line # | Download | only in scsipi
st_scsi.c revision 1.33
      1 /*	$NetBSD: st_scsi.c,v 1.33 2012/02/02 19:43:06 tls Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 1998, 2004 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Charles M. Hannum.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 /*
     33  * Originally written by Julian Elischer (julian (at) tfs.com)
     34  * for TRW Financial Systems for use under the MACH(2.5) operating system.
     35  *
     36  * TRW Financial Systems, in accordance with their agreement with Carnegie
     37  * Mellon University, makes this software available to CMU to distribute
     38  * or use in any manner that they see fit as long as this message is kept with
     39  * the software. For this reason TFS also grants any other persons or
     40  * organisations permission to use or modify this software.
     41  *
     42  * TFS supplies this software to be publicly redistributed
     43  * on the understanding that TFS is not responsible for the correct
     44  * functioning of this software in any circumstances.
     45  *
     46  * Ported to run under 386BSD by Julian Elischer (julian (at) tfs.com) Sept 1992
     47  * major changes by Julian Elischer (julian (at) jules.dialix.oz.au) May 1993
     48  *
     49  * A lot of rewhacking done by mjacob (mjacob (at) nas.nasa.gov).
     50  */
     51 
     52 #include <sys/cdefs.h>
     53 __KERNEL_RCSID(0, "$NetBSD: st_scsi.c,v 1.33 2012/02/02 19:43:06 tls Exp $");
     54 
     55 #include "opt_scsi.h"
     56 
     57 
     58 #include <sys/param.h>
     59 #include <sys/device.h>
     60 #include <sys/buf.h>
     61 #include <sys/bufq.h>
     62 #include <sys/conf.h>
     63 #include <sys/kernel.h>
     64 #include <sys/systm.h>
     65 
     66 #include <dev/scsipi/scsi_all.h>
     67 #include <dev/scsipi/scsi_tape.h>
     68 #include <dev/scsipi/stvar.h>
     69 
     70 static int	st_scsibus_match(device_t, cfdata_t, void *);
     71 static void	st_scsibus_attach(device_t, device_t, void *);
     72 static int	st_scsibus_ops(struct st_softc *, int, int);
     73 static int	st_scsibus_read_block_limits(struct st_softc *, int);
     74 static int	st_scsibus_mode_sense(struct st_softc *, int);
     75 static int	st_scsibus_cmprss(struct st_softc *, int, int);
     76 
     77 CFATTACH_DECL(st_scsibus, sizeof(struct st_softc),
     78     st_scsibus_match, st_scsibus_attach, stdetach, NULL);
     79 
     80 static const struct scsipi_inquiry_pattern st_scsibus_patterns[] = {
     81 	{T_SEQUENTIAL, T_REMOV,
     82 	 "",         "",                 ""},
     83 };
     84 
     85 static int
     86 st_scsibus_match(device_t parent, cfdata_t match,
     87     void *aux)
     88 {
     89 	struct scsipibus_attach_args *sa = aux;
     90 	int priority;
     91 
     92 	if (scsipi_periph_bustype(sa->sa_periph) != SCSIPI_BUSTYPE_SCSI)
     93 		return (0);
     94 
     95 	(void)scsipi_inqmatch(&sa->sa_inqbuf,
     96 	    st_scsibus_patterns,
     97 	    sizeof(st_scsibus_patterns)/sizeof(st_scsibus_patterns[0]),
     98 	    sizeof(st_scsibus_patterns[0]), &priority);
     99 	return (priority);
    100 }
    101 
    102 static void
    103 st_scsibus_attach(device_t parent, device_t self, void *aux)
    104 {
    105 	struct st_softc *st = device_private(self);
    106 
    107 	st->ops = st_scsibus_ops;
    108 	stattach(parent, st, aux);
    109 }
    110 
    111 static int
    112 st_scsibus_ops(struct st_softc *st, int op, int flags)
    113 {
    114 	switch(op) {
    115 	case ST_OPS_RBL:
    116 		return st_scsibus_read_block_limits(st, flags);
    117 	case ST_OPS_MODESENSE:
    118 		return st_scsibus_mode_sense(st, flags);
    119 	case ST_OPS_MODESELECT:
    120 		return st_mode_select(st, flags);
    121 	case ST_OPS_CMPRSS_ON:
    122 	case ST_OPS_CMPRSS_OFF:
    123 		return st_scsibus_cmprss(st, flags,
    124 		    (op == ST_OPS_CMPRSS_ON) ? 1 : 0);
    125 	default:
    126 		panic("st_scsibus_ops: invalid op");
    127 		return 0; /* XXX to appease gcc */
    128 	}
    129 	/* NOTREACHED */
    130 }
    131 
    132 /*
    133  * Ask the drive what it's min and max blk sizes are.
    134  */
    135 static int
    136 st_scsibus_read_block_limits(struct st_softc *st, int flags)
    137 {
    138 	struct scsi_block_limits cmd;
    139 	struct scsi_block_limits_data block_limits;
    140 	struct scsipi_periph *periph = st->sc_periph;
    141 	int error;
    142 
    143 	/*
    144 	 * do a 'Read Block Limits'
    145 	 */
    146 	memset(&cmd, 0, sizeof(cmd));
    147 	cmd.opcode = READ_BLOCK_LIMITS;
    148 
    149 	/*
    150 	 * do the command, update the global values
    151 	 */
    152 	error = scsipi_command(periph, (void *)&cmd, sizeof(cmd),
    153 	    (void *)&block_limits, sizeof(block_limits),
    154 	    ST_RETRIES, ST_CTL_TIME, NULL, flags | XS_CTL_DATA_IN);
    155 	if (error)
    156 		return (error);
    157 
    158 	st->blkmin = _2btol(block_limits.min_length);
    159 	st->blkmax = _3btol(block_limits.max_length);
    160 
    161 	SC_DEBUG(periph, SCSIPI_DB3,
    162 	    ("(%d <= blksize <= %d)\n", st->blkmin, st->blkmax));
    163 	return (0);
    164 }
    165 
    166 /*
    167  * Get the scsi driver to send a full inquiry to the
    168  * device and use the results to fill out the global
    169  * parameter structure.
    170  *
    171  * called from:
    172  * attach
    173  * open
    174  * ioctl (to reset original blksize)
    175  */
    176 static int
    177 st_scsibus_mode_sense(struct st_softc *st, int flags)
    178 {
    179 	u_int scsipi_sense_len;
    180 	int error;
    181 	struct scsipi_sense {
    182 		struct scsi_mode_parameter_header_6 header;
    183 		struct scsi_general_block_descriptor blk_desc;
    184 		u_char sense_data[MAX_PAGE_0_SIZE];
    185 	} scsipi_sense;
    186 	struct scsipi_periph *periph = st->sc_periph;
    187 
    188 	scsipi_sense_len = sizeof(scsipi_sense.header) +
    189 			   sizeof(scsipi_sense.blk_desc) +
    190 			   st->page_0_size;
    191 
    192 	/*
    193 	 * Set up a mode sense
    194 	 * We don't need the results. Just print them for our interest's sake,
    195 	 * if asked, or if we need it as a template for the mode select store
    196 	 * it away.
    197 	 */
    198 	error = scsipi_mode_sense(st->sc_periph, 0, SMS_PCTRL_CURRENT,
    199 	    &scsipi_sense.header, scsipi_sense_len, flags,
    200 	    ST_RETRIES, ST_CTL_TIME);
    201 	if (error)
    202 		return (error);
    203 
    204 	st->numblks = _3btol(scsipi_sense.blk_desc.nblocks);
    205 	st->media_blksize = _3btol(scsipi_sense.blk_desc.blklen);
    206 	st->media_density = scsipi_sense.blk_desc.density;
    207 	if (scsipi_sense.header.dev_spec & SMH_DSP_WRITE_PROT)
    208 		st->flags |= ST_READONLY;
    209 	else
    210 		st->flags &= ~ST_READONLY;
    211 	SC_DEBUG(periph, SCSIPI_DB3,
    212 	    ("density code %d, %d-byte blocks, write-%s, ",
    213 	    st->media_density, st->media_blksize,
    214 	    st->flags & ST_READONLY ? "protected" : "enabled"));
    215 	SC_DEBUG(periph, SCSIPI_DB3,
    216 	    ("%sbuffered\n",
    217 	    scsipi_sense.header.dev_spec & SMH_DSP_BUFF_MODE ? "" : "un"));
    218 	if (st->page_0_size)
    219 		memcpy(st->sense_data, scsipi_sense.sense_data,
    220 		    st->page_0_size);
    221 	periph->periph_flags |= PERIPH_MEDIA_LOADED;
    222 	return (0);
    223 }
    224 
    225 static int
    226 st_scsibus_cmprss(struct st_softc *st, int flags, int onoff)
    227 {
    228 	u_int scsi_dlen;
    229 	int byte2, page;
    230 	struct scsi_select {
    231 		struct scsi_mode_parameter_header_6 header;
    232 		struct scsi_general_block_descriptor blk_desc;
    233 		u_char pdata[MAX(sizeof(struct scsi_tape_dev_conf_page),
    234 		    sizeof(struct scsi_tape_dev_compression_page))];
    235 	} scsi_pdata;
    236 	struct scsi_tape_dev_conf_page *ptr;
    237 	struct scsi_tape_dev_compression_page *cptr;
    238 	struct scsipi_periph *periph = st->sc_periph;
    239 	int error, ison;
    240 
    241 	scsi_dlen = sizeof(scsi_pdata);
    242 	/*
    243 	 * Do DATA COMPRESSION page first.
    244 	 */
    245 	page = SMS_PCTRL_CURRENT | 0xf;
    246 	byte2 = 0;
    247 
    248 	/*
    249 	 * Do the MODE SENSE command...
    250 	 */
    251 again:
    252 	memset(&scsi_pdata, 0, scsi_dlen);
    253 	error = scsipi_mode_sense(periph, byte2, page,
    254 	    &scsi_pdata.header, scsi_dlen, flags, ST_RETRIES, ST_CTL_TIME);
    255 
    256 	if (error) {
    257 		if (byte2 != SMS_DBD) {
    258 			byte2 = SMS_DBD;
    259 			goto again;
    260 		}
    261 		/*
    262 		 * Try a different page?
    263 		 */
    264 		if (page == (SMS_PCTRL_CURRENT | 0xf)) {
    265 			page = SMS_PCTRL_CURRENT | 0x10;
    266 			byte2 = 0;
    267 			goto again;
    268 		}
    269 		return (error);
    270 	}
    271 
    272 	if (scsi_pdata.header.blk_desc_len)
    273 		ptr = (struct scsi_tape_dev_conf_page *) scsi_pdata.pdata;
    274 	else
    275 		ptr = (struct scsi_tape_dev_conf_page *) &scsi_pdata.blk_desc;
    276 
    277 	if ((page & SMS_PAGE_MASK) == 0xf) {
    278 		cptr = (struct scsi_tape_dev_compression_page *) ptr;
    279 		ison = (cptr->dce_dcc & DCP_DCE) != 0;
    280 		if (onoff)
    281 			cptr->dce_dcc |= DCP_DCE;
    282 		else
    283 			cptr->dce_dcc &= ~DCP_DCE;
    284 		cptr->pagecode &= ~0x80;
    285 	} else {
    286 		ison =  (ptr->sel_comp_alg != 0);
    287 		if (onoff)
    288 			ptr->sel_comp_alg = 1;
    289 		else
    290 			ptr->sel_comp_alg = 0;
    291 		ptr->pagecode &= ~0x80;
    292 		ptr->byte2 = 0;
    293 		ptr->active_partition = 0;
    294 		ptr->wb_full_ratio = 0;
    295 		ptr->rb_empty_ratio = 0;
    296 		ptr->byte8 &= ~0x30;
    297 		ptr->gap_size = 0;
    298 		ptr->byte10 &= ~0xe7;
    299 		ptr->ew_bufsize[0] = 0;
    300 		ptr->ew_bufsize[1] = 0;
    301 		ptr->ew_bufsize[2] = 0;
    302 		ptr->reserved = 0;
    303 	}
    304 	/*
    305 	 * There might be a virtue in actually doing the MODE SELECTS,
    306 	 * but let's not clog the bus over it.
    307 	 */
    308 	if (onoff == ison)
    309 		return (0);
    310 
    311 	/*
    312 	 * Set up for a mode select
    313 	 */
    314 
    315 	scsi_pdata.header.data_length = 0;
    316 	scsi_pdata.header.medium_type = 0;
    317 	if ((st->flags & ST_DONTBUFFER) == 0)
    318 		scsi_pdata.header.dev_spec = SMH_DSP_BUFF_MODE_ON;
    319 	else
    320 		scsi_pdata.header.dev_spec = 0;
    321 
    322 	if (scsi_pdata.header.blk_desc_len) {
    323 		scsi_pdata.blk_desc.density = 0;
    324 		scsi_pdata.blk_desc.nblocks[0] = 0;
    325 		scsi_pdata.blk_desc.nblocks[1] = 0;
    326 		scsi_pdata.blk_desc.nblocks[2] = 0;
    327 	}
    328 
    329 	/*
    330 	 * Do the command
    331 	 */
    332 	error = scsipi_mode_select(periph, SMS_PF, &scsi_pdata.header,
    333 	    scsi_dlen, flags, ST_RETRIES, ST_CTL_TIME);
    334 
    335 	if (error && (page & SMS_PAGE_MASK) == 0xf) {
    336 		/*
    337 		 * Try DEVICE CONFIGURATION page.
    338 		 */
    339 		page = SMS_PCTRL_CURRENT | 0x10;
    340 		goto again;
    341 	}
    342 	return (error);
    343 }
    344