st_scsi.c revision 1.30 1 /* $NetBSD: st_scsi.c,v 1.30 2009/08/15 12:44:55 pgoyette 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.30 2009/08/15 12:44:55 pgoyette Exp $");
54
55 #include "opt_scsi.h"
56 #include "rnd.h"
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, stactivate);
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,
155 flags | XS_CTL_DATA_IN | XS_CTL_DATA_ONSTACK);
156 if (error)
157 return (error);
158
159 st->blkmin = _2btol(block_limits.min_length);
160 st->blkmax = _3btol(block_limits.max_length);
161
162 SC_DEBUG(periph, SCSIPI_DB3,
163 ("(%d <= blksize <= %d)\n", st->blkmin, st->blkmax));
164 return (0);
165 }
166
167 /*
168 * Get the scsi driver to send a full inquiry to the
169 * device and use the results to fill out the global
170 * parameter structure.
171 *
172 * called from:
173 * attach
174 * open
175 * ioctl (to reset original blksize)
176 */
177 static int
178 st_scsibus_mode_sense(struct st_softc *st, int flags)
179 {
180 u_int scsipi_sense_len;
181 int error;
182 struct scsipi_sense {
183 struct scsi_mode_parameter_header_6 header;
184 struct scsi_general_block_descriptor blk_desc;
185 u_char sense_data[MAX_PAGE_0_SIZE];
186 } scsipi_sense;
187 struct scsipi_periph *periph = st->sc_periph;
188
189 scsipi_sense_len = sizeof(scsipi_sense.header) +
190 sizeof(scsipi_sense.blk_desc) +
191 st->page_0_size;
192
193 /*
194 * Set up a mode sense
195 * We don't need the results. Just print them for our interest's sake,
196 * if asked, or if we need it as a template for the mode select store
197 * it away.
198 */
199 error = scsipi_mode_sense(st->sc_periph, 0, SMS_PCTRL_CURRENT,
200 &scsipi_sense.header, scsipi_sense_len, flags | XS_CTL_DATA_ONSTACK,
201 ST_RETRIES, ST_CTL_TIME);
202 if (error)
203 return (error);
204
205 st->numblks = _3btol(scsipi_sense.blk_desc.nblocks);
206 st->media_blksize = _3btol(scsipi_sense.blk_desc.blklen);
207 st->media_density = scsipi_sense.blk_desc.density;
208 if (scsipi_sense.header.dev_spec & SMH_DSP_WRITE_PROT)
209 st->flags |= ST_READONLY;
210 else
211 st->flags &= ~ST_READONLY;
212 SC_DEBUG(periph, SCSIPI_DB3,
213 ("density code %d, %d-byte blocks, write-%s, ",
214 st->media_density, st->media_blksize,
215 st->flags & ST_READONLY ? "protected" : "enabled"));
216 SC_DEBUG(periph, SCSIPI_DB3,
217 ("%sbuffered\n",
218 scsipi_sense.header.dev_spec & SMH_DSP_BUFF_MODE ? "" : "un"));
219 if (st->page_0_size)
220 memcpy(st->sense_data, scsipi_sense.sense_data,
221 st->page_0_size);
222 periph->periph_flags |= PERIPH_MEDIA_LOADED;
223 return (0);
224 }
225
226 static int
227 st_scsibus_cmprss(struct st_softc *st, int flags, int onoff)
228 {
229 u_int scsi_dlen;
230 int byte2, page;
231 struct scsi_select {
232 struct scsi_mode_parameter_header_6 header;
233 struct scsi_general_block_descriptor blk_desc;
234 u_char pdata[MAX(sizeof(struct scsi_tape_dev_conf_page),
235 sizeof(struct scsi_tape_dev_compression_page))];
236 } scsi_pdata;
237 struct scsi_tape_dev_conf_page *ptr;
238 struct scsi_tape_dev_compression_page *cptr;
239 struct scsipi_periph *periph = st->sc_periph;
240 int error, ison;
241
242 scsi_dlen = sizeof(scsi_pdata);
243 /*
244 * Do DATA COMPRESSION page first.
245 */
246 page = SMS_PCTRL_CURRENT | 0xf;
247 byte2 = 0;
248
249 /*
250 * Do the MODE SENSE command...
251 */
252 again:
253 memset(&scsi_pdata, 0, scsi_dlen);
254 error = scsipi_mode_sense(periph, byte2, page,
255 &scsi_pdata.header, scsi_dlen, flags | XS_CTL_DATA_ONSTACK,
256 ST_RETRIES, ST_CTL_TIME);
257
258 if (error) {
259 if (byte2 != SMS_DBD) {
260 byte2 = SMS_DBD;
261 goto again;
262 }
263 /*
264 * Try a different page?
265 */
266 if (page == (SMS_PCTRL_CURRENT | 0xf)) {
267 page = SMS_PCTRL_CURRENT | 0x10;
268 byte2 = 0;
269 goto again;
270 }
271 return (error);
272 }
273
274 if (scsi_pdata.header.blk_desc_len)
275 ptr = (struct scsi_tape_dev_conf_page *) scsi_pdata.pdata;
276 else
277 ptr = (struct scsi_tape_dev_conf_page *) &scsi_pdata.blk_desc;
278
279 if ((page & SMS_PAGE_MASK) == 0xf) {
280 cptr = (struct scsi_tape_dev_compression_page *) ptr;
281 ison = (cptr->dce_dcc & DCP_DCE) != 0;
282 if (onoff)
283 cptr->dce_dcc |= DCP_DCE;
284 else
285 cptr->dce_dcc &= ~DCP_DCE;
286 cptr->pagecode &= ~0x80;
287 } else {
288 ison = (ptr->sel_comp_alg != 0);
289 if (onoff)
290 ptr->sel_comp_alg = 1;
291 else
292 ptr->sel_comp_alg = 0;
293 ptr->pagecode &= ~0x80;
294 ptr->byte2 = 0;
295 ptr->active_partition = 0;
296 ptr->wb_full_ratio = 0;
297 ptr->rb_empty_ratio = 0;
298 ptr->byte8 &= ~0x30;
299 ptr->gap_size = 0;
300 ptr->byte10 &= ~0xe7;
301 ptr->ew_bufsize[0] = 0;
302 ptr->ew_bufsize[1] = 0;
303 ptr->ew_bufsize[2] = 0;
304 ptr->reserved = 0;
305 }
306 /*
307 * There might be a virtue in actually doing the MODE SELECTS,
308 * but let's not clog the bus over it.
309 */
310 if (onoff == ison)
311 return (0);
312
313 /*
314 * Set up for a mode select
315 */
316
317 scsi_pdata.header.data_length = 0;
318 scsi_pdata.header.medium_type = 0;
319 if ((st->flags & ST_DONTBUFFER) == 0)
320 scsi_pdata.header.dev_spec = SMH_DSP_BUFF_MODE_ON;
321 else
322 scsi_pdata.header.dev_spec = 0;
323
324 if (scsi_pdata.header.blk_desc_len) {
325 scsi_pdata.blk_desc.density = 0;
326 scsi_pdata.blk_desc.nblocks[0] = 0;
327 scsi_pdata.blk_desc.nblocks[1] = 0;
328 scsi_pdata.blk_desc.nblocks[2] = 0;
329 }
330
331 /*
332 * Do the command
333 */
334 error = scsipi_mode_select(periph, SMS_PF, &scsi_pdata.header,
335 scsi_dlen, flags | XS_CTL_DATA_ONSTACK, ST_RETRIES, ST_CTL_TIME);
336
337 if (error && (page & SMS_PAGE_MASK) == 0xf) {
338 /*
339 * Try DEVICE CONFIGURATION page.
340 */
341 page = SMS_PCTRL_CURRENT | 0x10;
342 goto again;
343 }
344 return (error);
345 }
346