![[BACK]](/icons/back.gif){kind=icon}
Return to st.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi|
Return to st.c CVS log | Up to [local] / sys / scsi |
1.1 nbrk 1: /* $OpenBSD: st.c,v 1.75 2007/06/06 17:15:14 deraadt Exp $ */
2: /* $NetBSD: st.c,v 1.71 1997/02/21 23:03:49 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1994 Charles Hannum. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Charles Hannum.
18: * 4. The name of the author may not be used to endorse or promote products
19: * derived from this software without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31: */
32:
33: /*
34: * Originally written by Julian Elischer (julian@tfs.com)
35: * for TRW Financial Systems for use under the MACH(2.5) operating system.
36: *
37: * TRW Financial Systems, in accordance with their agreement with Carnegie
38: * Mellon University, makes this software available to CMU to distribute
39: * or use in any manner that they see fit as long as this message is kept with
40: * the software. For this reason TFS also grants any other persons or
41: * organisations permission to use or modify this software.
42: *
43: * TFS supplies this software to be publicly redistributed
44: * on the understanding that TFS is not responsible for the correct
45: * functioning of this software in any circumstances.
46: *
47: * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
48: * major changes by Julian Elischer (julian@jules.dialix.oz.au) May 1993
49: */
50:
51: /*
52: * To do:
53: * work out some better way of guessing what a good timeout is going
54: * to be depending on whether we expect to retension or not.
55: */
56:
57: #include <sys/types.h>
58: #include <sys/param.h>
59: #include <sys/systm.h>
60: #include <sys/timeout.h>
61: #include <sys/fcntl.h>
62: #include <sys/errno.h>
63: #include <sys/ioctl.h>
64: #include <sys/stat.h>
65: #include <sys/malloc.h>
66: #include <sys/buf.h>
67: #include <sys/proc.h>
68: #include <sys/user.h>
69: #include <sys/mtio.h>
70: #include <sys/device.h>
71: #include <sys/conf.h>
72:
73: #include <scsi/scsi_all.h>
74: #include <scsi/scsi_tape.h>
75: #include <scsi/scsiconf.h>
76:
77: /* Defines for device specific stuff */
78: #define DEF_FIXED_BSIZE 512
79: #define ST_RETRIES 4 /* only on non IO commands */
80:
81: #define STMODE(z) ( minor(z) & 0x03)
82: #define STUNIT(z) ((minor(z) >> 4) )
83:
84: #define ST_IO_TIME (3 * 60 * 1000) /* 3 minutes */
85: #define ST_CTL_TIME (30 * 1000) /* 30 seconds */
86: #define ST_SPC_TIME (4 * 60 * 60 * 1000) /* 4 hours */
87:
88: /*
89: * Maximum density code allowed in SCSI spec (SSC2R08f, Section 8.3).
90: */
91: #define SCSI_MAX_DENSITY_CODE 0xff
92:
93: /*
94: * Define various devices that we know mis-behave in some way,
95: * and note how they are bad, so we can correct for them
96: */
97: struct modes {
98: u_int quirks; /* same definitions as in quirkdata */
99: int blksize;
100: u_int8_t density;
101: };
102:
103: struct quirkdata {
104: u_int quirks;
105: #define ST_Q_FORCE_BLKSIZE 0x0001
106: #define ST_Q_SENSE_HELP 0x0002 /* must do READ for good MODE SENSE */
107: #define ST_Q_IGNORE_LOADS 0x0004
108: #define ST_Q_BLKSIZE 0x0008 /* variable-block media_blksize > 0 */
109: #define ST_Q_UNIMODAL 0x0010 /* unimode drive rejects mode select */
110: struct modes modes;
111: };
112:
113: struct st_quirk_inquiry_pattern {
114: struct scsi_inquiry_pattern pattern;
115: struct quirkdata quirkdata;
116: };
117:
118: const struct st_quirk_inquiry_pattern st_quirk_patterns[] = {
119: {{T_SEQUENTIAL, T_REMOV,
120: " ", " ", " "}, {0,
121: {ST_Q_FORCE_BLKSIZE, 512, 0}}}, /* minor 0-3 */
122: {{T_SEQUENTIAL, T_REMOV,
123: "TANDBERG", " TDC 3600 ", ""}, {0,
124: {0, 0, 0}}}, /* minor 0-3 */
125: {{T_SEQUENTIAL, T_REMOV,
126: "TANDBERG", " TDC 3800 ", ""}, {0,
127: {ST_Q_FORCE_BLKSIZE, 512, 0}}}, /* minor 0-3 */
128: /*
129: * At least -005 and -007 need this. I'll assume they all do unless I
130: * hear otherwise. - mycroft, 31MAR1994
131: */
132: {{T_SEQUENTIAL, T_REMOV,
133: "ARCHIVE ", "VIPER 2525 25462", ""}, {0,
134: {ST_Q_SENSE_HELP, 0, 0}}}, /* minor 0-3 */
135: /*
136: * One user reports that this works for his tape drive. It probably
137: * needs more work. - mycroft, 09APR1994
138: */
139: {{T_SEQUENTIAL, T_REMOV,
140: "SANKYO ", "CP525 ", ""}, {0,
141: {ST_Q_FORCE_BLKSIZE, 512, 0}}}, /* minor 0-3 */
142: {{T_SEQUENTIAL, T_REMOV,
143: "ANRITSU ", "DMT780 ", ""}, {0,
144: {ST_Q_FORCE_BLKSIZE, 512, 0}}}, /* minor 0-3 */
145: {{T_SEQUENTIAL, T_REMOV,
146: "ARCHIVE ", "VIPER 150 21247", ""}, {0,
147: {0, 0, 0}}}, /* minor 0-3 */
148: {{T_SEQUENTIAL, T_REMOV,
149: "ARCHIVE ", "VIPER 150 21531", ""}, {0,
150: {ST_Q_SENSE_HELP, 0, 0}}}, /* minor 0-3 */
151: {{T_SEQUENTIAL, T_REMOV,
152: "WANGTEK ", "5099ES SCSI", ""}, {0,
153: {ST_Q_FORCE_BLKSIZE, 512, 0}}}, /* minor 0-3 */
154: {{T_SEQUENTIAL, T_REMOV,
155: "WANGTEK ", "5150ES SCSI", ""}, {0,
156: {ST_Q_FORCE_BLKSIZE, 512, 0}}}, /* minor 0-3 */
157: {{T_SEQUENTIAL, T_REMOV,
158: "WANGTEK ", "5525ES SCSI REV7", ""}, {0,
159: {0, 0, 0}}}, /* minor 0-3 */
160: {{T_SEQUENTIAL, T_REMOV,
161: "WangDAT ", "Model 1300 ", ""}, {0,
162: {0, 0, 0}}}, /* minor 0-3 */
163: {{T_SEQUENTIAL, T_REMOV,
164: "EXABYTE ", "EXB-8200 ", "263H"}, {0,
165: {0, 0, 0}}}, /* minor 0-3 */
166: {{T_SEQUENTIAL, T_REMOV,
167: "HP ", "T4000s ", ""}, {ST_Q_UNIMODAL,
168: {0, 0, QIC_3095}}}, /* minor 0-3 */
169: #if 0
170: {{T_SEQUENTIAL, T_REMOV,
171: "EXABYTE ", "EXB-8200 ", ""}, {0,
172: {0, 0, 0}}}, /* minor 0-3 */
173: #endif
174: {{T_SEQUENTIAL, T_REMOV,
175: "WANGTEK ", "5150ES SCSI FA15\0""01 A", "????"}, {0,
176: {ST_Q_IGNORE_LOADS, 0, 0}}}, /* minor 0-3 */
177: {{T_SEQUENTIAL, T_REMOV,
178: "TEAC ", "MT-2ST/N50 ", ""}, {ST_Q_IGNORE_LOADS,
179: {0, 0, 0}}}, /* minor 0-3 */
180: };
181:
182: #define NOEJECT 0
183: #define EJECT 1
184:
185: #define NOREWIND 0
186: #define DOREWIND 1
187:
188: struct st_softc {
189: struct device sc_dev;
190: /*--------------------present operating parameters, flags etc.----------------*/
191: int flags; /* see below */
192: u_int quirks; /* quirks for the open mode */
193: int blksize; /* blksize we are using */
194: u_int8_t density; /* present density */
195: short mt_resid; /* last (short) resid */
196: short mt_erreg; /* last error (sense key) seen */
197: /*--------------------device/scsi parameters----------------------------------*/
198: struct scsi_link *sc_link; /* our link to the adpter etc. */
199: /*--------------------parameters reported by the device ----------------------*/
200: int blkmin; /* min blk size */
201: int blkmax; /* max blk size */
202: const struct quirkdata *quirkdata; /* if we have a rogue entry */
203: /*--------------------parameters reported by the device for this media--------*/
204: u_int64_t numblks; /* nominal blocks capacity */
205: u_int32_t media_blksize; /* 0 if not ST_FIXEDBLOCKS */
206: u_int32_t media_density; /* this is what it said when asked */
207: int media_fileno; /* relative to BOT. -1 means unknown. */
208: int media_blkno; /* relative to BOF. -1 means unknown. */
209: /*--------------------quirks for the whole drive------------------------------*/
210: u_int drive_quirks; /* quirks of this drive */
211: /*--------------------How we should set up when opening each minor device----*/
212: struct modes modes; /* plus more for each mode */
213: u_int8_t modeflags; /* flags for the modes */
214: #define DENSITY_SET_BY_USER 0x01
215: #define DENSITY_SET_BY_QUIRK 0x02
216: #define BLKSIZE_SET_BY_USER 0x04
217: #define BLKSIZE_SET_BY_QUIRK 0x08
218: /*--------------------storage for sense data returned by the drive------------*/
219: struct buf buf_queue; /* the queue of pending IO operations */
220: struct timeout sc_timeout;
221: };
222:
223:
224: int stmatch(struct device *, void *, void *);
225: void stattach(struct device *, struct device *, void *);
226: void st_identify_drive(struct st_softc *, struct scsi_inquiry_data *);
227: void st_loadquirks(struct st_softc *);
228: int st_mount_tape(dev_t, int);
229: void st_unmount(struct st_softc *, int, int);
230: int st_decide_mode(struct st_softc *, int);
231: void ststart(void *);
232: void strestart(void *);
233: int st_read(struct st_softc *, char *, int, int);
234: int st_read_block_limits(struct st_softc *, int);
235: int st_mode_sense(struct st_softc *, int);
236: int st_mode_select(struct st_softc *, int);
237: int st_space(struct st_softc *, int, u_int, int);
238: int st_write_filemarks(struct st_softc *, int, int);
239: int st_check_eod(struct st_softc *, int, int *, int);
240: int st_load(struct st_softc *, u_int, int);
241: int st_rewind(struct st_softc *, u_int, int);
242: int st_interpret_sense(struct scsi_xfer *);
243: int st_touch_tape(struct st_softc *);
244: int st_erase(struct st_softc *, int, int);
245:
246: struct cfattach st_ca = {
247: sizeof(struct st_softc), stmatch, stattach
248: };
249:
250: struct cfdriver st_cd = {
251: NULL, "st", DV_TAPE
252: };
253:
254: struct scsi_device st_switch = {
255: st_interpret_sense,
256: ststart,
257: NULL,
258: NULL,
259: };
260:
261: #define ST_INFO_VALID 0x0001
262: #define ST_BLOCK_SET 0x0002 /* block size, mode set by ioctl */
263: #define ST_WRITTEN 0x0004 /* data have been written, EOD needed */
264: #define ST_FIXEDBLOCKS 0x0008
265: #define ST_AT_FILEMARK 0x0010
266: #define ST_EIO_PENDING 0x0020 /* we couldn't report it then (had data) */
267: #define ST_READONLY 0x0080 /* st_mode_sense says write protected */
268: #define ST_FM_WRITTEN 0x0100 /*
269: * EOF file mark written -- used with
270: * ~ST_WRITTEN to indicate that multiple file
271: * marks have been written
272: */
273: #define ST_BLANK_READ 0x0200 /* BLANK CHECK encountered already */
274: #define ST_2FM_AT_EOD 0x0400 /* write 2 file marks at EOD */
275: #define ST_MOUNTED 0x0800 /* Device is presently mounted */
276: #define ST_DONTBUFFER 0x1000 /* Disable buffering/caching */
277:
278: #define ST_PER_ACTION (ST_AT_FILEMARK | ST_EIO_PENDING | ST_BLANK_READ)
279: #define ST_PER_MOUNT (ST_INFO_VALID | ST_BLOCK_SET | ST_WRITTEN | \
280: ST_FIXEDBLOCKS | ST_READONLY | ST_FM_WRITTEN | \
281: ST_2FM_AT_EOD | ST_PER_ACTION)
282:
283: const struct scsi_inquiry_pattern st_patterns[] = {
284: {T_SEQUENTIAL, T_REMOV,
285: "", "", ""},
286: };
287:
288: int
289: stmatch(parent, match, aux)
290: struct device *parent;
291: void *match, *aux;
292: {
293: struct scsi_attach_args *sa = aux;
294: int priority;
295:
296: (void)scsi_inqmatch(sa->sa_inqbuf,
297: st_patterns, sizeof(st_patterns)/sizeof(st_patterns[0]),
298: sizeof(st_patterns[0]), &priority);
299: return (priority);
300: }
301:
302: /*
303: * The routine called by the low level scsi routine when it discovers
304: * A device suitable for this driver
305: */
306: void
307: stattach(parent, self, aux)
308: struct device *parent, *self;
309: void *aux;
310: {
311: struct st_softc *st = (void *)self;
312: struct scsi_attach_args *sa = aux;
313: struct scsi_link *sc_link = sa->sa_sc_link;
314:
315: SC_DEBUG(sc_link, SDEV_DB2, ("stattach:\n"));
316:
317: /*
318: * Store information needed to contact our base driver
319: */
320: st->sc_link = sc_link;
321: sc_link->device = &st_switch;
322: sc_link->device_softc = st;
323:
324: /*
325: * Check if the drive is a known criminal and take
326: * Any steps needed to bring it into line
327: */
328: st_identify_drive(st, sa->sa_inqbuf);
329: printf("\n");
330:
331: timeout_set(&st->sc_timeout, strestart, st);
332:
333: /*
334: * Set up the buf queue for this device
335: */
336: st->buf_queue.b_active = 0;
337: st->buf_queue.b_actf = 0;
338: st->buf_queue.b_actb = &st->buf_queue.b_actf;
339:
340: /* Start up with media position unknown. */
341: st->media_fileno = -1;
342: st->media_blkno = -1;
343:
344: /*
345: * Reset the media loaded flag, sometimes the data
346: * acquired at boot time is not quite accurate. This
347: * will be checked again at the first open.
348: */
349: sc_link->flags &= ~SDEV_MEDIA_LOADED;
350: }
351:
352: /*
353: * Use the inquiry routine in 'scsi_base' to get drive info so we can
354: * Further tailor our behaviour.
355: */
356: void
357: st_identify_drive(st, inqbuf)
358: struct st_softc *st;
359: struct scsi_inquiry_data *inqbuf;
360: {
361: const struct st_quirk_inquiry_pattern *finger;
362: int priority;
363:
364: finger = (const struct st_quirk_inquiry_pattern *)scsi_inqmatch(inqbuf,
365: st_quirk_patterns,
366: sizeof(st_quirk_patterns)/sizeof(st_quirk_patterns[0]),
367: sizeof(st_quirk_patterns[0]), &priority);
368: if (priority != 0) {
369: st->quirkdata = &finger->quirkdata;
370: st->drive_quirks = finger->quirkdata.quirks;
371: st->quirks = finger->quirkdata.quirks; /* start value */
372: st_loadquirks(st);
373: }
374: }
375:
376: /*
377: * initialise the subdevices to the default (QUIRK) state.
378: * this will remove any setting made by the system operator or previous
379: * operations.
380: */
381: void
382: st_loadquirks(st)
383: struct st_softc *st;
384: {
385: const struct modes *mode;
386: struct modes *mode2;
387:
388: mode = &st->quirkdata->modes;
389: mode2 = &st->modes;
390: bzero(mode2, sizeof(struct modes));
391: st->modeflags &= ~(BLKSIZE_SET_BY_QUIRK |
392: DENSITY_SET_BY_QUIRK | BLKSIZE_SET_BY_USER |
393: DENSITY_SET_BY_USER);
394: if ((mode->quirks | st->drive_quirks) & ST_Q_FORCE_BLKSIZE) {
395: mode2->blksize = mode->blksize;
396: st->modeflags |= BLKSIZE_SET_BY_QUIRK;
397: }
398: if (mode->density) {
399: mode2->density = mode->density;
400: st->modeflags |= DENSITY_SET_BY_QUIRK;
401: }
402: }
403:
404: /*
405: * open the device.
406: */
407: int
408: stopen(dev, flags, fmt, p)
409: dev_t dev;
410: int flags;
411: int fmt;
412: struct proc *p;
413: {
414: struct scsi_link *sc_link;
415: struct st_softc *st;
416: int error = 0, unit;
417:
418: unit = STUNIT(dev);
419: if (unit >= st_cd.cd_ndevs)
420: return (ENXIO);
421: st = st_cd.cd_devs[unit];
422: if (!st)
423: return (ENXIO);
424:
425: sc_link = st->sc_link;
426:
427: SC_DEBUG(sc_link, SDEV_DB1, ("open: dev=0x%x (unit %d (of %d))\n", dev,
428: unit, st_cd.cd_ndevs));
429:
430: /*
431: * Tape is an exclusive media. Only one open at a time.
432: */
433: if (sc_link->flags & SDEV_OPEN) {
434: SC_DEBUG(sc_link, SDEV_DB4, ("already open\n"));
435: return (EBUSY);
436: }
437:
438: /* Use st_interpret_sense() now. */
439: sc_link->flags |= SDEV_OPEN;
440:
441: /*
442: * Check the unit status. This clears any outstanding errors and
443: * will ensure that media is present.
444: */
445: error = scsi_test_unit_ready(sc_link, TEST_READY_RETRIES,
446: SCSI_SILENT | SCSI_IGNORE_MEDIA_CHANGE |
447: SCSI_IGNORE_ILLEGAL_REQUEST);
448:
449: /*
450: * Terminate any exising mount session if there is no media.
451: */
452: if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0)
453: st_unmount(st, NOEJECT, DOREWIND);
454:
455: if (error) {
456: sc_link->flags &= ~SDEV_OPEN;
457: return (error);
458: }
459:
460: if ((st->flags & ST_MOUNTED) == 0) {
461: error = st_mount_tape(dev, flags);
462: if (error) {
463: sc_link->flags &= ~SDEV_OPEN;
464: return (error);
465: }
466: }
467:
468: /*
469: * Make sure that a tape opened in write-only mode will have
470: * file marks written on it when closed, even if not written to.
471: * This is for SUN compatibility
472: */
473: if ((flags & O_ACCMODE) == FWRITE)
474: st->flags |= ST_WRITTEN;
475:
476: SC_DEBUG(sc_link, SDEV_DB2, ("open complete\n"));
477: return (0);
478: }
479:
480: /*
481: * close the device.. only called if we are the LAST
482: * occurence of an open device
483: */
484: int
485: stclose(dev, flags, mode, p)
486: dev_t dev;
487: int flags;
488: int mode;
489: struct proc *p;
490: {
491: struct st_softc *st = st_cd.cd_devs[STUNIT(dev)];
492:
493: SC_DEBUG(st->sc_link, SDEV_DB1, ("closing\n"));
494: if ((st->flags & (ST_WRITTEN | ST_FM_WRITTEN)) == ST_WRITTEN)
495: st_write_filemarks(st, 1, 0);
496: switch (STMODE(dev)) {
497: case 0: /* normal */
498: st_unmount(st, NOEJECT, DOREWIND);
499: break;
500: case 3: /* eject, no rewind */
501: st_unmount(st, EJECT, NOREWIND);
502: break;
503: case 1: /* no rewind */
504: /* leave mounted unless media seems to have been removed */
505: if (!(st->sc_link->flags & SDEV_MEDIA_LOADED))
506: st_unmount(st, NOEJECT, NOREWIND);
507: break;
508: case 2: /* rewind, eject */
509: st_unmount(st, EJECT, DOREWIND);
510: break;
511: }
512: st->sc_link->flags &= ~SDEV_OPEN;
513: timeout_del(&st->sc_timeout);
514:
515: return 0;
516: }
517:
518: /*
519: * Start a new mount session.
520: * Copy in all the default parameters from the selected device mode.
521: * and try guess any that seem to be defaulted.
522: */
523: int
524: st_mount_tape(dev, flags)
525: dev_t dev;
526: int flags;
527: {
528: int unit;
529: u_int mode;
530: struct st_softc *st;
531: struct scsi_link *sc_link;
532: int error = 0;
533:
534: unit = STUNIT(dev);
535: mode = STMODE(dev);
536: st = st_cd.cd_devs[unit];
537: sc_link = st->sc_link;
538:
539: if (st->flags & ST_MOUNTED)
540: return 0;
541:
542: SC_DEBUG(sc_link, SDEV_DB1, ("mounting\n"));
543: st->quirks = st->drive_quirks | st->modes.quirks;
544: /*
545: * If the media is new, then make sure we give it a chance to
546: * to do a 'load' instruction. (We assume it is new.)
547: */
548: if ((error = st_load(st, LD_LOAD, 0)) != 0)
549: return error;
550: /*
551: * Throw another dummy instruction to catch
552: * 'Unit attention' errors. Some drives appear to give
553: * these after doing a Load instruction.
554: * (noteably some DAT drives)
555: */
556: /* XXX */
557: scsi_test_unit_ready(sc_link, TEST_READY_RETRIES, SCSI_SILENT);
558:
559: /*
560: * Some devices can't tell you much until they have been
561: * asked to look at the media. This quirk does this.
562: */
563: if (st->quirks & ST_Q_SENSE_HELP)
564: if ((error = st_touch_tape(st)) != 0)
565: return error;
566: /*
567: * Load the physical device parameters
568: * loads: blkmin, blkmax
569: */
570: if (!(sc_link->flags & SDEV_ATAPI) &&
571: (error = st_read_block_limits(st, 0)) != 0) {
572: return error;
573: }
574:
575: /*
576: * Load the media dependent parameters
577: * includes: media_blksize,media_density,numblks
578: * As we have a tape in, it should be reflected here.
579: * If not you may need the "quirk" above.
580: */
581: if ((error = st_mode_sense(st, 0)) != 0)
582: return error;
583:
584: /*
585: * If we have gained a permanent density from somewhere,
586: * then use it in preference to the one supplied by
587: * default by the driver.
588: */
589: if (st->modeflags & (DENSITY_SET_BY_QUIRK | DENSITY_SET_BY_USER))
590: st->density = st->modes.density;
591: else
592: st->density = st->media_density;
593: /*
594: * If we have gained a permanent blocksize
595: * then use it in preference to the one supplied by
596: * default by the driver.
597: */
598: st->flags &= ~ST_FIXEDBLOCKS;
599: if (st->modeflags & (BLKSIZE_SET_BY_QUIRK | BLKSIZE_SET_BY_USER)) {
600: st->blksize = st->modes.blksize;
601: if (st->blksize)
602: st->flags |= ST_FIXEDBLOCKS;
603: } else {
604: if ((error = st_decide_mode(st, FALSE)) != 0)
605: return error;
606: }
607: if ((error = st_mode_select(st, 0)) != 0) {
608: printf("%s: cannot set selected mode\n", st->sc_dev.dv_xname);
609: return error;
610: }
611: scsi_prevent(sc_link, PR_PREVENT,
612: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY);
613: st->flags |= ST_MOUNTED;
614: sc_link->flags |= SDEV_MEDIA_LOADED; /* move earlier? */
615:
616: return 0;
617: }
618:
619: /*
620: * End the present mount session.
621: * Rewind, and optionally eject the tape.
622: * Reset various flags to indicate that all new
623: * operations require another mount operation
624: */
625: void
626: st_unmount(st, eject, rewind)
627: struct st_softc *st;
628: int eject, rewind;
629: {
630: struct scsi_link *sc_link = st->sc_link;
631: int nmarks;
632:
633: st->media_fileno = -1;
634: st->media_blkno = -1;
635:
636: if (!(st->flags & ST_MOUNTED))
637: return;
638: SC_DEBUG(sc_link, SDEV_DB1, ("unmounting\n"));
639: st_check_eod(st, FALSE, &nmarks, SCSI_IGNORE_NOT_READY);
640: if (rewind)
641: st_rewind(st, 0, SCSI_IGNORE_NOT_READY);
642: scsi_prevent(sc_link, PR_ALLOW,
643: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY);
644: if (eject)
645: st_load(st, LD_UNLOAD, SCSI_IGNORE_NOT_READY);
646: st->flags &= ~ST_MOUNTED;
647: sc_link->flags &= ~SDEV_MEDIA_LOADED;
648: }
649:
650: /*
651: * Given all we know about the device, media, mode, 'quirks' and
652: * initial operation, make a decision as to how we should be set
653: * to run (regarding blocking and EOD marks)
654: */
655: int
656: st_decide_mode(st, first_read)
657: struct st_softc *st;
658: int first_read;
659: {
660: struct scsi_link *sc_link = st->sc_link;
661:
662: SC_DEBUG(sc_link, SDEV_DB2, ("starting block mode decision\n"));
663:
664: /* ATAPI tapes are always fixed blocksize. */
665: if (sc_link->flags & SDEV_ATAPI) {
666: st->flags |= ST_FIXEDBLOCKS;
667: if (st->media_blksize > 0)
668: st->blksize = st->media_blksize;
669: else
670: st->blksize = DEF_FIXED_BSIZE;
671: goto done;
672: }
673:
674: /*
675: * If the drive can only handle fixed-length blocks and only at
676: * one size, perhaps we should just do that.
677: */
678: if (st->blkmin && (st->blkmin == st->blkmax)) {
679: st->flags |= ST_FIXEDBLOCKS;
680: st->blksize = st->blkmin;
681: SC_DEBUG(sc_link, SDEV_DB3,
682: ("blkmin == blkmax of %d\n", st->blkmin));
683: goto done;
684: }
685: /*
686: * If the tape density mandates (or even suggests) use of fixed
687: * or variable-length blocks, comply.
688: */
689: switch (st->density) {
690: case HALFINCH_800:
691: case HALFINCH_1600:
692: case HALFINCH_6250:
693: case DDS:
694: st->flags &= ~ST_FIXEDBLOCKS;
695: st->blksize = 0;
696: SC_DEBUG(sc_link, SDEV_DB3, ("density specified variable\n"));
697: goto done;
698: case QIC_11:
699: case QIC_24:
700: case QIC_120:
701: case QIC_150:
702: case QIC_525:
703: case QIC_1320:
704: st->flags |= ST_FIXEDBLOCKS;
705: if (st->media_blksize > 0)
706: st->blksize = st->media_blksize;
707: else
708: st->blksize = DEF_FIXED_BSIZE;
709: SC_DEBUG(sc_link, SDEV_DB3, ("density specified fixed\n"));
710: goto done;
711: }
712: /*
713: * If we're about to read the tape, perhaps we should choose
714: * fixed or variable-length blocks and block size according to
715: * what the drive found on the tape.
716: */
717: if (first_read &&
718: (!(st->quirks & ST_Q_BLKSIZE) || (st->media_blksize == 0) ||
719: (st->media_blksize == DEF_FIXED_BSIZE) ||
720: (st->media_blksize == 1024))) {
721: if (st->media_blksize > 0)
722: st->flags |= ST_FIXEDBLOCKS;
723: else
724: st->flags &= ~ST_FIXEDBLOCKS;
725: st->blksize = st->media_blksize;
726: SC_DEBUG(sc_link, SDEV_DB3,
727: ("Used media_blksize of %d\n", st->media_blksize));
728: goto done;
729: }
730: /*
731: * We're getting no hints from any direction. Choose variable-
732: * length blocks arbitrarily.
733: */
734: st->flags &= ~ST_FIXEDBLOCKS;
735: st->blksize = 0;
736: SC_DEBUG(sc_link, SDEV_DB3,
737: ("Give up and default to variable mode\n"));
738:
739: done:
740: /*
741: * Decide whether or not to write two file marks to signify end-
742: * of-data. Make the decision as a function of density. If
743: * the decision is not to use a second file mark, the SCSI BLANK
744: * CHECK condition code will be recognized as end-of-data when
745: * first read.
746: * (I think this should be a by-product of fixed/variable..julian)
747: */
748: switch (st->density) {
749: /* case 8 mm: What is the SCSI density code for 8 mm, anyway? */
750: case QIC_11:
751: case QIC_24:
752: case QIC_120:
753: case QIC_150:
754: case QIC_525:
755: case QIC_1320:
756: st->flags &= ~ST_2FM_AT_EOD;
757: break;
758: default:
759: st->flags |= ST_2FM_AT_EOD;
760: }
761: return 0;
762: }
763:
764: /*
765: * Actually translate the requested transfer into
766: * one the physical driver can understand
767: * The transfer is described by a buf and will include
768: * only one physical transfer.
769: */
770: void
771: ststrategy(bp)
772: struct buf *bp;
773: {
774: struct st_softc *st = st_cd.cd_devs[STUNIT(bp->b_dev)];
775: struct buf *dp;
776: int s;
777:
778: SC_DEBUG(st->sc_link, SDEV_DB2, ("ststrategy: %ld bytes @ blk %d\n",
779: bp->b_bcount, bp->b_blkno));
780: /*
781: * If it's a null transfer, return immediately.
782: */
783: if (bp->b_bcount == 0)
784: goto done;
785: /*
786: * Odd sized request on fixed drives are verboten
787: */
788: if (st->flags & ST_FIXEDBLOCKS) {
789: if (bp->b_bcount % st->blksize) {
790: printf("%s: bad request, must be multiple of %d\n",
791: st->sc_dev.dv_xname, st->blksize);
792: bp->b_error = EIO;
793: goto bad;
794: }
795: }
796: /*
797: * as are out-of-range requests on variable drives.
798: */
799: else if (bp->b_bcount < st->blkmin ||
800: (st->blkmax && bp->b_bcount > st->blkmax)) {
801: printf("%s: bad request, must be between %d and %d\n",
802: st->sc_dev.dv_xname, st->blkmin, st->blkmax);
803: bp->b_error = EIO;
804: goto bad;
805: }
806: s = splbio();
807:
808: /*
809: * Place it in the queue of activities for this tape
810: * at the end (a bit silly because we only have on user..
811: * (but it could fork()))
812: */
813: dp = &st->buf_queue;
814: bp->b_actf = NULL;
815: bp->b_actb = dp->b_actb;
816: *dp->b_actb = bp;
817: dp->b_actb = &bp->b_actf;
818:
819: /*
820: * Tell the device to get going on the transfer if it's
821: * not doing anything, otherwise just wait for completion
822: * (All a bit silly if we're only allowing 1 open but..)
823: */
824: ststart(st);
825:
826: splx(s);
827: return;
828: bad:
829: bp->b_flags |= B_ERROR;
830: done:
831: /*
832: * Correctly set the buf to indicate a completed xfer
833: */
834: bp->b_resid = bp->b_bcount;
835: s = splbio();
836: biodone(bp);
837: splx(s);
838: }
839:
840: /*
841: * ststart looks to see if there is a buf waiting for the device
842: * and that the device is not already busy. If both are true,
843: * It dequeues the buf and creates a scsi command to perform the
844: * transfer required. The transfer request will call scsi_done
845: * on completion, which will in turn call this routine again
846: * so that the next queued transfer is performed.
847: * The bufs are queued by the strategy routine (ststrategy)
848: *
849: * This routine is also called after other non-queued requests
850: * have been made of the scsi driver, to ensure that the queue
851: * continues to be drained.
852: * ststart() is called at splbio from ststrategy, strestart and scsi_done()
853: */
854: void
855: ststart(v)
856: void *v;
857: {
858: struct st_softc *st = v;
859: struct scsi_link *sc_link = st->sc_link;
860: struct buf *bp, *dp;
861: struct scsi_rw_tape cmd;
862: int flags, error;
863:
864: SC_DEBUG(sc_link, SDEV_DB2, ("ststart\n"));
865:
866: splassert(IPL_BIO);
867:
868: /*
869: * See if there is a buf to do and we are not already
870: * doing one
871: */
872: while (sc_link->openings > 0) {
873: /* if a special awaits, let it proceed first */
874: if (sc_link->flags & SDEV_WAITING) {
875: sc_link->flags &= ~SDEV_WAITING;
876: wakeup((caddr_t)sc_link);
877: return;
878: }
879:
880: dp = &st->buf_queue;
881: if ((bp = dp->b_actf) == NULL)
882: return;
883: if ((dp = bp->b_actf) != NULL)
884: dp->b_actb = bp->b_actb;
885: else
886: st->buf_queue.b_actb = bp->b_actb;
887: *bp->b_actb = dp;
888:
889: /*
890: * if the device has been unmounted by the user
891: * then throw away all requests until done
892: */
893: if (!(st->flags & ST_MOUNTED) ||
894: !(sc_link->flags & SDEV_MEDIA_LOADED)) {
895: /* make sure that one implies the other.. */
896: sc_link->flags &= ~SDEV_MEDIA_LOADED;
897: bp->b_flags |= B_ERROR;
898: bp->b_resid = bp->b_bcount;
899: bp->b_error = EIO;
900: biodone(bp);
901: continue;
902: }
903: /*
904: * only FIXEDBLOCK devices have pending operations
905: */
906: if (st->flags & ST_FIXEDBLOCKS) {
907: /*
908: * If we are at a filemark but have not reported it yet
909: * then we should report it now
910: */
911: if (st->flags & ST_AT_FILEMARK) {
912: if ((bp->b_flags & B_READ) == B_WRITE) {
913: /*
914: * Handling of ST_AT_FILEMARK in
915: * st_space will fill in the right file
916: * mark count.
917: * Back up over filemark
918: */
919: if (st_space(st, 0, SP_FILEMARKS, 0)) {
920: bp->b_flags |= B_ERROR;
921: bp->b_resid = bp->b_bcount;
922: bp->b_error = EIO;
923: biodone(bp);
924: continue;
925: }
926: } else {
927: bp->b_resid = bp->b_bcount;
928: bp->b_error = 0;
929: bp->b_flags &= ~B_ERROR;
930: st->flags &= ~ST_AT_FILEMARK;
931: biodone(bp);
932: continue; /* seek more work */
933: }
934: }
935: /*
936: * If we are at EIO (e.g. EOM) but have not reported it
937: * yet then we should report it now
938: */
939: if (st->flags & ST_EIO_PENDING) {
940: bp->b_resid = bp->b_bcount;
941: bp->b_error = EIO;
942: bp->b_flags |= B_ERROR;
943: st->flags &= ~ST_EIO_PENDING;
944: biodone(bp);
945: continue; /* seek more work */
946: }
947: }
948:
949: /*
950: * Fill out the scsi command
951: */
952: bzero(&cmd, sizeof(cmd));
953: if ((bp->b_flags & B_READ) == B_WRITE) {
954: cmd.opcode = WRITE;
955: st->flags &= ~ST_FM_WRITTEN;
956: st->flags |= ST_WRITTEN;
957: flags = SCSI_DATA_OUT;
958: } else {
959: cmd.opcode = READ;
960: flags = SCSI_DATA_IN;
961: }
962:
963: /*
964: * Handle "fixed-block-mode" tape drives by using the
965: * block count instead of the length.
966: */
967: if (st->flags & ST_FIXEDBLOCKS) {
968: cmd.byte2 |= SRW_FIXED;
969: _lto3b(bp->b_bcount / st->blksize, cmd.len);
970: } else
971: _lto3b(bp->b_bcount, cmd.len);
972:
973: if (st->media_blkno != -1) {
974: /* Update block count now, errors will set it to -1. */
975: if (st->flags & ST_FIXEDBLOCKS)
976: st->media_blkno += _3btol(cmd.len);
977: else if (cmd.len != 0)
978: st->media_blkno++;
979: }
980:
981: /*
982: * go ask the adapter to do all this for us
983: */
984: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *) &cmd,
985: sizeof(cmd), (u_char *) bp->b_data, bp->b_bcount, 0,
986: ST_IO_TIME, bp, flags | SCSI_NOSLEEP);
987: switch (error) {
988: case 0:
989: timeout_del(&st->sc_timeout);
990: break;
991: case EAGAIN:
992: /*
993: * The device can't start another i/o. Try again later.
994: */
995: dp->b_actf = bp;
996: timeout_add(&st->sc_timeout, 1);
997: return;
998: default:
999: printf("%s: not queued\n", st->sc_dev.dv_xname);
1000: break;
1001: }
1002: } /* go back and see if we can cram more work in.. */
1003: }
1004:
1005: void
1006: strestart(v)
1007: void *v;
1008: {
1009: int s;
1010:
1011: s = splbio();
1012: ststart(v);
1013: splx(s);
1014: }
1015:
1016: int
1017: stread(dev, uio, iomode)
1018: dev_t dev;
1019: struct uio *uio;
1020: int iomode;
1021: {
1022: struct st_softc *st = st_cd.cd_devs[STUNIT(dev)];
1023:
1024: return (physio(ststrategy, NULL, dev, B_READ,
1025: st->sc_link->adapter->scsi_minphys, uio));
1026: }
1027:
1028: int
1029: stwrite(dev, uio, iomode)
1030: dev_t dev;
1031: struct uio *uio;
1032: int iomode;
1033: {
1034: struct st_softc *st = st_cd.cd_devs[STUNIT(dev)];
1035:
1036: return (physio(ststrategy, NULL, dev, B_WRITE,
1037: st->sc_link->adapter->scsi_minphys, uio));
1038: }
1039:
1040: /*
1041: * Perform special action on behalf of the user;
1042: * knows about the internals of this device
1043: */
1044: int
1045: stioctl(dev, cmd, arg, flag, p)
1046: dev_t dev;
1047: u_long cmd;
1048: caddr_t arg;
1049: int flag;
1050: struct proc *p;
1051: {
1052: int error = 0;
1053: int unit;
1054: int nmarks;
1055: int flags;
1056: struct st_softc *st;
1057: int hold_blksize;
1058: u_int8_t hold_density;
1059: struct mtop *mt = (struct mtop *) arg;
1060: int number;
1061:
1062: /*
1063: * Find the device that the user is talking about
1064: */
1065: flags = 0; /* give error messages, act on errors etc. */
1066: unit = STUNIT(dev);
1067: st = st_cd.cd_devs[unit];
1068: hold_blksize = st->blksize;
1069: hold_density = st->density;
1070:
1071: switch (cmd) {
1072:
1073: case MTIOCGET: {
1074: struct mtget *g = (struct mtget *) arg;
1075:
1076: /*
1077: * (to get the current state of READONLY)
1078: */
1079: error = st_mode_sense(st, SCSI_SILENT);
1080: if (error)
1081: break;
1082:
1083: SC_DEBUG(st->sc_link, SDEV_DB1, ("[ioctl: get status]\n"));
1084: bzero(g, sizeof(struct mtget));
1085: g->mt_type = 0x7; /* Ultrix compat *//*? */
1086: g->mt_blksiz = st->blksize;
1087: g->mt_density = st->density;
1088: g->mt_mblksiz = st->modes.blksize;
1089: g->mt_mdensity = st->modes.density;
1090: if (st->flags & ST_READONLY)
1091: g->mt_dsreg |= MT_DS_RDONLY;
1092: if (st->flags & ST_MOUNTED)
1093: g->mt_dsreg |= MT_DS_MOUNTED;
1094: g->mt_resid = st->mt_resid;
1095: g->mt_erreg = st->mt_erreg;
1096: g->mt_fileno = st->media_fileno;
1097: g->mt_blkno = st->media_blkno;
1098: /*
1099: * clear latched errors.
1100: */
1101: st->mt_resid = 0;
1102: st->mt_erreg = 0;
1103: break;
1104: }
1105: case MTIOCTOP: {
1106:
1107: SC_DEBUG(st->sc_link, SDEV_DB1,
1108: ("[ioctl: op=0x%x count=0x%x]\n", mt->mt_op, mt->mt_count));
1109:
1110: number = mt->mt_count;
1111: switch (mt->mt_op) {
1112: case MTWEOF: /* write an end-of-file record */
1113: error = st_write_filemarks(st, number, flags);
1114: break;
1115: case MTBSF: /* backward space file */
1116: number = -number;
1117: case MTFSF: /* forward space file */
1118: error = st_check_eod(st, FALSE, &nmarks, flags);
1119: if (!error)
1120: error = st_space(st, number - nmarks,
1121: SP_FILEMARKS, flags);
1122: break;
1123: case MTBSR: /* backward space record */
1124: number = -number;
1125: case MTFSR: /* forward space record */
1126: error = st_check_eod(st, TRUE, &nmarks, flags);
1127: if (!error)
1128: error = st_space(st, number, SP_BLKS, flags);
1129: break;
1130: case MTREW: /* rewind */
1131: error = st_rewind(st, 0, flags);
1132: break;
1133: case MTOFFL: /* rewind and put the drive offline */
1134: st_unmount(st, EJECT, DOREWIND);
1135: break;
1136: case MTNOP: /* no operation, sets status only */
1137: break;
1138: case MTRETEN: /* retension the tape */
1139: error = st_load(st, LD_RETENSION, flags);
1140: if (!error)
1141: error = st_load(st, LD_LOAD, flags);
1142: break;
1143: case MTEOM: /* forward space to end of media */
1144: error = st_check_eod(st, FALSE, &nmarks, flags);
1145: if (!error)
1146: error = st_space(st, 1, SP_EOM, flags);
1147: break;
1148: case MTCACHE: /* enable controller cache */
1149: st->flags &= ~ST_DONTBUFFER;
1150: goto try_new_value;
1151: case MTNOCACHE: /* disable controller cache */
1152: st->flags |= ST_DONTBUFFER;
1153: goto try_new_value;
1154: case MTERASE: /* erase volume */
1155: error = st_erase(st, number, flags);
1156: break;
1157: case MTSETBSIZ: /* Set block size for device */
1158: if (number == 0) {
1159: st->flags &= ~ST_FIXEDBLOCKS;
1160: } else {
1161: if ((st->blkmin || st->blkmax) &&
1162: (number < st->blkmin ||
1163: number > st->blkmax)) {
1164: error = EINVAL;
1165: break;
1166: }
1167: st->flags |= ST_FIXEDBLOCKS;
1168: }
1169: st->blksize = number;
1170: st->flags |= ST_BLOCK_SET; /*XXX */
1171: goto try_new_value;
1172:
1173: case MTSETDNSTY: /* Set density for device and mode */
1174: if (number < 0 || number > SCSI_MAX_DENSITY_CODE) {
1175: error = EINVAL;
1176: break;
1177: } else
1178: st->density = number;
1179: goto try_new_value;
1180:
1181: default:
1182: error = EINVAL;
1183: }
1184: break;
1185: }
1186: case MTIOCIEOT:
1187: case MTIOCEEOT:
1188: break;
1189:
1190: #if 0
1191: case MTIOCRDSPOS:
1192: error = st_rdpos(st, 0, (u_int32_t *) arg);
1193: break;
1194:
1195: case MTIOCRDHPOS:
1196: error = st_rdpos(st, 1, (u_int32_t *) arg);
1197: break;
1198:
1199: case MTIOCSLOCATE:
1200: error = st_setpos(st, 0, (u_int32_t *) arg);
1201: break;
1202:
1203: case MTIOCHLOCATE:
1204: error = st_setpos(st, 1, (u_int32_t *) arg);
1205: break;
1206: #endif
1207:
1208: default:
1209: error = scsi_do_ioctl(st->sc_link, dev, cmd, arg, flag, p);
1210: break;
1211: }
1212: return error;
1213: /*-----------------------------*/
1214: try_new_value:
1215: /*
1216: * Check that the mode being asked for is aggreeable to the
1217: * drive. If not, put it back the way it was.
1218: */
1219: if ((error = st_mode_select(st, 0)) != 0) {/* put it back as it was */
1220: printf("%s: cannot set selected mode\n", st->sc_dev.dv_xname);
1221: st->density = hold_density;
1222: st->blksize = hold_blksize;
1223: if (st->blksize)
1224: st->flags |= ST_FIXEDBLOCKS;
1225: else
1226: st->flags &= ~ST_FIXEDBLOCKS;
1227: return error;
1228: }
1229: /*
1230: * As the drive liked it, if we are setting a new default,
1231: * set it into the structures as such.
1232: */
1233: switch (mt->mt_op) {
1234: case MTSETBSIZ:
1235: st->modes.blksize = st->blksize;
1236: st->modeflags |= BLKSIZE_SET_BY_USER;
1237: break;
1238: case MTSETDNSTY:
1239: st->modes.density = st->density;
1240: st->modeflags |= DENSITY_SET_BY_USER;
1241: break;
1242: }
1243:
1244: return 0;
1245: }
1246:
1247: /*
1248: * Do a synchronous read.
1249: */
1250: int
1251: st_read(st, buf, size, flags)
1252: struct st_softc *st;
1253: int size;
1254: int flags;
1255: char *buf;
1256: {
1257: struct scsi_rw_tape cmd;
1258:
1259: /*
1260: * If it's a null transfer, return immediately
1261: */
1262: if (size == 0)
1263: return 0;
1264: bzero(&cmd, sizeof(cmd));
1265: cmd.opcode = READ;
1266: if (st->flags & ST_FIXEDBLOCKS) {
1267: cmd.byte2 |= SRW_FIXED;
1268: _lto3b(size / (st->blksize ? st->blksize : DEF_FIXED_BSIZE),
1269: cmd.len);
1270: } else
1271: _lto3b(size, cmd.len);
1272: return scsi_scsi_cmd(st->sc_link, (struct scsi_generic *) &cmd,
1273: sizeof(cmd), (u_char *) buf, size, 0, ST_IO_TIME, NULL,
1274: flags | SCSI_DATA_IN);
1275: }
1276:
1277: /*
1278: * Ask the drive what its min and max blk sizes are.
1279: */
1280: int
1281: st_read_block_limits(st, flags)
1282: struct st_softc *st;
1283: int flags;
1284: {
1285: struct scsi_block_limits cmd;
1286: struct scsi_block_limits_data block_limits;
1287: struct scsi_link *sc_link = st->sc_link;
1288: int error;
1289:
1290: /*
1291: * First check if we have it all loaded
1292: */
1293: if ((sc_link->flags & SDEV_MEDIA_LOADED))
1294: return 0;
1295:
1296: /*
1297: * do a 'Read Block Limits'
1298: */
1299: bzero(&cmd, sizeof(cmd));
1300: cmd.opcode = READ_BLOCK_LIMITS;
1301:
1302: /*
1303: * do the command, update the global values
1304: */
1305: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *) &cmd,
1306: sizeof(cmd), (u_char *) &block_limits, sizeof(block_limits),
1307: ST_RETRIES, ST_CTL_TIME, NULL, flags | SCSI_DATA_IN);
1308: if (error)
1309: return error;
1310:
1311: st->blkmin = _2btol(block_limits.min_length);
1312: st->blkmax = _3btol(block_limits.max_length);
1313:
1314: SC_DEBUG(sc_link, SDEV_DB3,
1315: ("(%d <= blksize <= %d)\n", st->blkmin, st->blkmax));
1316: return 0;
1317: }
1318:
1319: /*
1320: * Get the scsi driver to send a full inquiry to the
1321: * device and use the results to fill out the global
1322: * parameter structure.
1323: *
1324: * called from:
1325: * attach
1326: * open
1327: * ioctl (to reset original blksize)
1328: */
1329: int
1330: st_mode_sense(st, flags)
1331: struct st_softc *st;
1332: int flags;
1333: {
1334: union scsi_mode_sense_buf *data;
1335: struct scsi_link *sc_link = st->sc_link;
1336: u_int64_t block_count;
1337: u_int32_t density, block_size;
1338: u_char *page0 = NULL;
1339: u_int8_t dev_spec;
1340: int error, big;
1341:
1342: data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
1343: if (data == NULL)
1344: return (ENOMEM);
1345:
1346: /*
1347: * Ask for page 0 (vendor specific) mode sense data.
1348: */
1349: error = scsi_do_mode_sense(sc_link, 0, data, (void **)&page0,
1350: &density, &block_count, &block_size, 1, flags | SCSI_SILENT, &big);
1351: if (error != 0) {
1352: free(data, M_TEMP);
1353: return (error);
1354: }
1355:
1356: /* It is valid for no page0 to be available. */
1357:
1358: if (big)
1359: dev_spec = data->hdr_big.dev_spec;
1360: else
1361: dev_spec = data->hdr.dev_spec;
1362:
1363: if (dev_spec & SMH_DSP_WRITE_PROT)
1364: st->flags |= ST_READONLY;
1365: else
1366: st->flags &= ~ST_READONLY;
1367:
1368: st->numblks = block_count;
1369: st->media_blksize = block_size;
1370: st->media_density = density;
1371:
1372: SC_DEBUG(sc_link, SDEV_DB3,
1373: ("density code 0x%x, %d-byte blocks, write-%s, ",
1374: st->media_density, st->media_blksize,
1375: st->flags & ST_READONLY ? "protected" : "enabled"));
1376: SC_DEBUGN(sc_link, SDEV_DB3,
1377: ("%sbuffered\n", dev_spec & SMH_DSP_BUFF_MODE ? "" : "un"));
1378:
1379: sc_link->flags |= SDEV_MEDIA_LOADED;
1380:
1381: free(data, M_TEMP);
1382: return (0);
1383: }
1384:
1385: /*
1386: * Send a filled out parameter structure to the drive to
1387: * set it into the desire modes etc.
1388: */
1389: int
1390: st_mode_select(st, flags)
1391: struct st_softc *st;
1392: int flags;
1393: {
1394: union scsi_mode_sense_buf *inbuf, *outbuf;
1395: struct scsi_blk_desc general;
1396: struct scsi_link *sc_link = st->sc_link;
1397: u_int8_t *page0 = NULL;
1398: int error, big, page0_size;
1399:
1400: inbuf = malloc(sizeof(*inbuf), M_TEMP, M_NOWAIT);
1401: if (inbuf == NULL)
1402: return (ENOMEM);
1403: outbuf = malloc(sizeof(*outbuf), M_TEMP, M_NOWAIT);
1404: if (outbuf == NULL) {
1405: free(inbuf, M_TEMP);
1406: return (ENOMEM);
1407: }
1408:
1409: /*
1410: * This quirk deals with drives that have only one valid mode and think
1411: * this gives them license to reject all mode selects, even if the
1412: * selected mode is the one that is supported.
1413: */
1414: if (st->quirks & ST_Q_UNIMODAL) {
1415: SC_DEBUG(sc_link, SDEV_DB3,
1416: ("not setting density 0x%x blksize 0x%x\n",
1417: st->density, st->blksize));
1418: free(inbuf, M_TEMP);
1419: free(outbuf, M_TEMP);
1420: return (0);
1421: }
1422:
1423: if (sc_link->flags & SDEV_ATAPI) {
1424: free(inbuf, M_TEMP);
1425: free(outbuf, M_TEMP);
1426: return (0);
1427: }
1428:
1429: bzero(outbuf, sizeof(*outbuf));
1430: bzero(&general, sizeof(general));
1431:
1432: general.density = st->density;
1433: if (st->flags & ST_FIXEDBLOCKS)
1434: _lto3b(st->blksize, general.blklen);
1435:
1436: /*
1437: * Ask for page 0 (vendor specific) mode sense data.
1438: */
1439: error = scsi_do_mode_sense(sc_link, 0, inbuf, (void **)&page0, NULL,
1440: NULL, NULL, 1, flags | SCSI_SILENT, &big);
1441: if (error != 0) {
1442: free(inbuf, M_TEMP);
1443: free(outbuf, M_TEMP);
1444: return (error);
1445: }
1446:
1447: if (page0 == NULL) {
1448: page0_size = 0;
1449: } else if (big == 0) {
1450: page0_size = inbuf->hdr.data_length +
1451: sizeof(inbuf->hdr.data_length) - sizeof(inbuf->hdr) -
1452: inbuf->hdr.blk_desc_len;
1453: memcpy(&outbuf->buf[sizeof(outbuf->hdr)+ sizeof(general)],
1454: page0, page0_size);
1455: } else {
1456: page0_size = _2btol(inbuf->hdr_big.data_length) +
1457: sizeof(inbuf->hdr_big.data_length) -
1458: sizeof(inbuf->hdr_big) -
1459: _2btol(inbuf->hdr_big.blk_desc_len);
1460: memcpy(&outbuf->buf[sizeof(outbuf->hdr_big) + sizeof(general)],
1461: page0, page0_size);
1462: }
1463:
1464: /*
1465: * Set up for a mode select.
1466: */
1467: if (big == 0) {
1468: outbuf->hdr.data_length = sizeof(outbuf->hdr) +
1469: sizeof(general) + page0_size -
1470: sizeof(outbuf->hdr.data_length);
1471: if ((st->flags & ST_DONTBUFFER) == 0)
1472: outbuf->hdr.dev_spec = SMH_DSP_BUFF_MODE_ON;
1473: outbuf->hdr.blk_desc_len = sizeof(general);
1474: memcpy(&outbuf->buf[sizeof(outbuf->hdr)],
1475: &general, sizeof(general));
1476: error = scsi_mode_select(st->sc_link, 0, &outbuf->hdr,
1477: flags, ST_CTL_TIME);
1478: free(inbuf, M_TEMP);
1479: free(outbuf, M_TEMP);
1480: return (error);
1481: }
1482:
1483: /* MODE SENSE (10) header was returned, so use MODE SELECT (10). */
1484: _lto2b((sizeof(outbuf->hdr_big) + sizeof(general) + page0_size -
1485: sizeof(outbuf->hdr_big.data_length)), outbuf->hdr_big.data_length);
1486: if ((st->flags & ST_DONTBUFFER) == 0)
1487: outbuf->hdr_big.dev_spec = SMH_DSP_BUFF_MODE_ON;
1488: _lto2b(sizeof(general), outbuf->hdr_big.blk_desc_len);
1489: memcpy(&outbuf->buf[sizeof(outbuf->hdr_big)], &general,
1490: sizeof(general));
1491:
1492: error = scsi_mode_select_big(st->sc_link, 0, &outbuf->hdr_big,
1493: flags, ST_CTL_TIME);
1494: free(inbuf, M_TEMP);
1495: free(outbuf, M_TEMP);
1496: return (error);
1497: }
1498:
1499: /*
1500: * issue an erase command
1501: */
1502: int
1503: st_erase(st, full, flags)
1504: struct st_softc *st;
1505: int full, flags;
1506: {
1507: struct scsi_erase cmd;
1508: int tmo;
1509:
1510: /*
1511: * Full erase means set LONG bit in erase command, which asks
1512: * the drive to erase the entire unit. Without this bit, we're
1513: * asking the drive to write an erase gap.
1514: */
1515: bzero(&cmd, sizeof(cmd));
1516: cmd.opcode = ERASE;
1517: if (full) {
1518: cmd.byte2 = SE_IMMED|SE_LONG;
1519: tmo = ST_SPC_TIME;
1520: } else {
1521: cmd.byte2 = SE_IMMED;
1522: tmo = ST_IO_TIME;
1523: }
1524:
1525: /*
1526: * XXX We always do this asynchronously, for now. How long should
1527: * we wait if we want to (eventually) to it synchronously?
1528: */
1529: return (scsi_scsi_cmd(st->sc_link, (struct scsi_generic *)&cmd,
1530: sizeof(cmd), 0, 0, ST_RETRIES, tmo, NULL, flags));
1531: }
1532:
1533: /*
1534: * skip N blocks/filemarks/seq filemarks/eom
1535: */
1536: int
1537: st_space(st, number, what, flags)
1538: struct st_softc *st;
1539: u_int what;
1540: int flags;
1541: int number;
1542: {
1543: struct scsi_space cmd;
1544: int error;
1545:
1546: switch (what) {
1547: case SP_BLKS:
1548: if (st->flags & ST_PER_ACTION) {
1549: if (number > 0) {
1550: st->flags &= ~ST_PER_ACTION;
1551: return EIO;
1552: } else if (number < 0) {
1553: if (st->flags & ST_AT_FILEMARK) {
1554: /*
1555: * Handling of ST_AT_FILEMARK
1556: * in st_space will fill in the
1557: * right file mark count.
1558: */
1559: error = st_space(st, 0, SP_FILEMARKS,
1560: flags);
1561: if (error)
1562: return error;
1563: }
1564: if (st->flags & ST_BLANK_READ) {
1565: st->flags &= ~ST_BLANK_READ;
1566: return EIO;
1567: }
1568: st->flags &= ~ST_EIO_PENDING;
1569: }
1570: }
1571: break;
1572: case SP_FILEMARKS:
1573: if (st->flags & ST_EIO_PENDING) {
1574: if (number > 0) {
1575: /* pretend we just discovered the error */
1576: st->flags &= ~ST_EIO_PENDING;
1577: return EIO;
1578: } else if (number < 0) {
1579: /* back away from the error */
1580: st->flags &= ~ST_EIO_PENDING;
1581: }
1582: }
1583: if (st->flags & ST_AT_FILEMARK) {
1584: st->flags &= ~ST_AT_FILEMARK;
1585: number--;
1586: }
1587: if ((st->flags & ST_BLANK_READ) && (number < 0)) {
1588: /* back away from unwritten tape */
1589: st->flags &= ~ST_BLANK_READ;
1590: number++; /* XXX dubious */
1591: }
1592: break;
1593: case SP_EOM:
1594: if (st->flags & ST_EIO_PENDING) {
1595: /* pretend we just discovered the error */
1596: st->flags &= ~ST_EIO_PENDING;
1597: return EIO;
1598: }
1599: if (st->flags & ST_AT_FILEMARK)
1600: st->flags &= ~ST_AT_FILEMARK;
1601: break;
1602: }
1603: if (number == 0)
1604: return 0;
1605:
1606: bzero(&cmd, sizeof(cmd));
1607: cmd.opcode = SPACE;
1608: cmd.byte2 = what;
1609: _lto3b(number, cmd.number);
1610:
1611: error = scsi_scsi_cmd(st->sc_link, (struct scsi_generic *) &cmd,
1612: sizeof(cmd), 0, 0, 0, ST_SPC_TIME, NULL, flags);
1613:
1614: if (error != 0) {
1615: st->media_fileno = -1;
1616: st->media_blkno = -1;
1617: } else {
1618: switch (what) {
1619: case SP_BLKS:
1620: if (st->media_blkno != -1) {
1621: st->media_blkno += number;
1622: if (st->media_blkno < 0)
1623: st->media_blkno = -1;
1624: }
1625: break;
1626: case SP_FILEMARKS:
1627: if (st->media_fileno != -1) {
1628: st->media_fileno += number;
1629: st->media_blkno = 0;
1630: }
1631: break;
1632: default:
1633: st->media_fileno = -1;
1634: st->media_blkno = -1;
1635: break;
1636: }
1637: }
1638:
1639: return (error);
1640: }
1641:
1642: /*
1643: * write N filemarks
1644: */
1645: int
1646: st_write_filemarks(st, number, flags)
1647: struct st_softc *st;
1648: int flags;
1649: int number;
1650: {
1651: struct scsi_write_filemarks cmd;
1652: int error;
1653:
1654: /*
1655: * It's hard to write a negative number of file marks.
1656: * Don't try.
1657: */
1658: if (number < 0)
1659: return EINVAL;
1660: switch (number) {
1661: case 0: /* really a command to sync the drive's buffers */
1662: break;
1663: case 1:
1664: if (st->flags & ST_FM_WRITTEN) /* already have one down */
1665: st->flags &= ~ST_WRITTEN;
1666: else
1667: st->flags |= ST_FM_WRITTEN;
1668: st->flags &= ~ST_PER_ACTION;
1669: break;
1670: default:
1671: st->flags &= ~(ST_PER_ACTION | ST_WRITTEN);
1672: }
1673:
1674: bzero(&cmd, sizeof(cmd));
1675: cmd.opcode = WRITE_FILEMARKS;
1676: _lto3b(number, cmd.number);
1677:
1678: error = scsi_scsi_cmd(st->sc_link, (struct scsi_generic *) &cmd,
1679: sizeof(cmd), 0, 0, 0, ST_IO_TIME * 4, NULL, flags);
1680:
1681: if (error != 0) {
1682: st->media_fileno = -1;
1683: st->media_blkno = -1;
1684: } else if (st->media_fileno != -1) {
1685: st->media_fileno += number;
1686: st->media_blkno = 0;
1687: }
1688:
1689: return (error);
1690: }
1691:
1692: /*
1693: * Make sure the right number of file marks is on tape if the
1694: * tape has been written. If the position argument is true,
1695: * leave the tape positioned where it was originally.
1696: *
1697: * nmarks returns the number of marks to skip (or, if position
1698: * true, which were skipped) to get back original position.
1699: */
1700: int
1701: st_check_eod(st, position, nmarks, flags)
1702: struct st_softc *st;
1703: int position;
1704: int *nmarks;
1705: int flags;
1706: {
1707: int error;
1708:
1709: switch (st->flags & (ST_WRITTEN | ST_FM_WRITTEN | ST_2FM_AT_EOD)) {
1710: default:
1711: *nmarks = 0;
1712: return 0;
1713: case ST_WRITTEN:
1714: case ST_WRITTEN | ST_FM_WRITTEN | ST_2FM_AT_EOD:
1715: *nmarks = 1;
1716: break;
1717: case ST_WRITTEN | ST_2FM_AT_EOD:
1718: *nmarks = 2;
1719: }
1720: error = st_write_filemarks(st, *nmarks, flags);
1721: if (position && !error)
1722: error = st_space(st, -*nmarks, SP_FILEMARKS, flags);
1723: return error;
1724: }
1725:
1726: /*
1727: * load/unload/retension
1728: */
1729: int
1730: st_load(st, type, flags)
1731: struct st_softc *st;
1732: u_int type;
1733: int flags;
1734: {
1735: struct scsi_load cmd;
1736:
1737: st->media_fileno = -1;
1738: st->media_blkno = -1;
1739:
1740: if (type != LD_LOAD) {
1741: int error;
1742: int nmarks;
1743:
1744: error = st_check_eod(st, FALSE, &nmarks, flags);
1745: if (error)
1746: return error;
1747: }
1748: if (st->quirks & ST_Q_IGNORE_LOADS) {
1749: if (type == LD_LOAD) {
1750: /*
1751: * If we ignore loads, at least we should try a rewind.
1752: */
1753: return st_rewind(st, 0, flags);
1754: }
1755: return (0);
1756: }
1757:
1758:
1759: bzero(&cmd, sizeof(cmd));
1760: cmd.opcode = LOAD;
1761: cmd.how = type;
1762:
1763: return scsi_scsi_cmd(st->sc_link, (struct scsi_generic *) &cmd,
1764: sizeof(cmd), 0, 0, ST_RETRIES, ST_SPC_TIME, NULL, flags);
1765: }
1766:
1767: /*
1768: * Rewind the device
1769: */
1770: int
1771: st_rewind(st, immediate, flags)
1772: struct st_softc *st;
1773: u_int immediate;
1774: int flags;
1775: {
1776: struct scsi_rewind cmd;
1777: int error;
1778: int nmarks;
1779:
1780: error = st_check_eod(st, FALSE, &nmarks, flags);
1781: if (error)
1782: return error;
1783: st->flags &= ~ST_PER_ACTION;
1784:
1785: bzero(&cmd, sizeof(cmd));
1786: cmd.opcode = REWIND;
1787: cmd.byte2 = immediate;
1788:
1789: error = scsi_scsi_cmd(st->sc_link, (struct scsi_generic *) &cmd,
1790: sizeof(cmd), 0, 0, ST_RETRIES,
1791: immediate ? ST_CTL_TIME: ST_SPC_TIME, NULL, flags);
1792:
1793: if (error == 0) {
1794: st->media_fileno = 0;
1795: st->media_blkno = 0;
1796: }
1797:
1798: return (error);
1799: }
1800:
1801: /*
1802: * Look at the returned sense and act on the error and detirmine
1803: * The unix error number to pass back... (0 = report no error)
1804: * (-1 = continue processing)
1805: */
1806: int
1807: st_interpret_sense(xs)
1808: struct scsi_xfer *xs;
1809: {
1810: struct scsi_sense_data *sense = &xs->sense;
1811: struct scsi_link *sc_link = xs->sc_link;
1812: struct st_softc *st = sc_link->device_softc;
1813: struct buf *bp = xs->bp;
1814: u_int8_t serr = sense->error_code & SSD_ERRCODE;
1815: u_int8_t skey = sense->flags & SSD_KEY;
1816: int32_t info;
1817:
1818: if (((sc_link->flags & SDEV_OPEN) == 0) ||
1819: (serr != SSD_ERRCODE_CURRENT && serr != SSD_ERRCODE_DEFERRED))
1820: return (EJUSTRETURN); /* let the generic code handle it */
1821:
1822: switch (skey) {
1823:
1824: /*
1825: * We do custom processing in st for the unit becoming ready case.
1826: * in this case we do not allow xs->retries to be decremented
1827: * only on the "Unit Becoming Ready" case. This is because tape
1828: * drives report "Unit Becoming Ready" when loading media, etc.
1829: * and can take a long time. Rather than having a massive timeout
1830: * for all operations (which would cause other problems) we allow
1831: * operations to wait (but be interruptable with Ctrl-C) forever
1832: * as long as the drive is reporting that it is becoming ready.
1833: * all other cases are handled as per the default.
1834: */
1835:
1836: case SKEY_NOT_READY:
1837: if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
1838: return (0);
1839: switch (ASC_ASCQ(sense)) {
1840: case SENSE_NOT_READY_BECOMING_READY:
1841: SC_DEBUG(sc_link, SDEV_DB1, ("not ready: busy (%#x)\n",
1842: sense->add_sense_code_qual));
1843: /* don't count this as a retry */
1844: xs->retries++;
1845: return (scsi_delay(xs, 1));
1846: default:
1847: return (EJUSTRETURN);
1848: }
1849: case SKEY_NO_SENSE:
1850: case SKEY_RECOVERED_ERROR:
1851: case SKEY_MEDIUM_ERROR:
1852: case SKEY_VOLUME_OVERFLOW:
1853: case SKEY_BLANK_CHECK:
1854: break;
1855: default:
1856: return (EJUSTRETURN);
1857: }
1858:
1859: /*
1860: * Get the sense fields and work out what code
1861: */
1862: if (sense->error_code & SSD_ERRCODE_VALID)
1863: info = _4btol(sense->info);
1864: else
1865: info = xs->datalen; /* bad choice if fixed blocks */
1866: if (st->flags & ST_FIXEDBLOCKS) {
1867: xs->resid = info * st->blksize;
1868: if (sense->flags & SSD_EOM) {
1869: st->flags |= ST_EIO_PENDING;
1870: if (bp)
1871: bp->b_resid = xs->resid;
1872: }
1873: if (sense->flags & SSD_FILEMARK) {
1874: st->flags |= ST_AT_FILEMARK;
1875: if (st->media_fileno != -1) {
1876: st->media_fileno++;
1877: st->media_blkno = 0;
1878: }
1879: if (bp)
1880: bp->b_resid = xs->resid;
1881: }
1882: if (sense->flags & SSD_ILI) {
1883: st->flags |= ST_EIO_PENDING;
1884: if (bp)
1885: bp->b_resid = xs->resid;
1886: if (sense->error_code & SSD_ERRCODE_VALID &&
1887: (xs->flags & SCSI_SILENT) == 0)
1888: printf("%s: block wrong size, %d blocks residual\n",
1889: st->sc_dev.dv_xname, info);
1890:
1891: /*
1892: * This quirk code helps the drive read
1893: * the first tape block, regardless of
1894: * format. That is required for these
1895: * drives to return proper MODE SENSE
1896: * information.
1897: */
1898: if ((st->quirks & ST_Q_SENSE_HELP) &&
1899: !(sc_link->flags & SDEV_MEDIA_LOADED))
1900: st->blksize -= 512;
1901: }
1902: /*
1903: * If no data was transferred, return immediately
1904: */
1905: if (xs->resid >= xs->datalen) {
1906: if (st->flags & ST_EIO_PENDING)
1907: return EIO;
1908: if (st->flags & ST_AT_FILEMARK) {
1909: if (bp)
1910: bp->b_resid = xs->resid;
1911: return 0;
1912: }
1913: }
1914: } else { /* must be variable mode */
1915: xs->resid = xs->datalen; /* to be sure */
1916: if (sense->flags & SSD_EOM)
1917: return EIO;
1918: if (sense->flags & SSD_FILEMARK) {
1919: if (st->media_fileno != -1) {
1920: st->media_fileno++;
1921: st->media_blkno = 0;
1922: }
1923: if (bp)
1924: bp->b_resid = bp->b_bcount;
1925: return 0;
1926: }
1927: if (sense->flags & SSD_ILI) {
1928: if (info < 0) {
1929: /*
1930: * the record was bigger than the read
1931: */
1932: if ((xs->flags & SCSI_SILENT) == 0)
1933: printf("%s: %d-byte record too big\n",
1934: st->sc_dev.dv_xname,
1935: xs->datalen - info);
1936: return (EIO);
1937: } else if (info > xs->datalen) {
1938: /*
1939: * huh? the residual is bigger than the request
1940: */
1941: if ((xs->flags & SCSI_SILENT) == 0) {
1942: printf(
1943: "%s: bad residual %d out of %d\n",
1944: st->sc_dev.dv_xname, info,
1945: xs->datalen);
1946: return (EIO);
1947: }
1948: }
1949: xs->resid = info;
1950: if (bp)
1951: bp->b_resid = info;
1952: return (0);
1953: }
1954: }
1955:
1956: if (skey == SKEY_BLANK_CHECK) {
1957: /*
1958: * This quirk code helps the drive read the first tape block,
1959: * regardless of format. That is required for these drives to
1960: * return proper MODE SENSE information.
1961: */
1962: if ((st->quirks & ST_Q_SENSE_HELP) &&
1963: !(sc_link->flags & SDEV_MEDIA_LOADED)) {
1964: /* still starting */
1965: st->blksize -= 512;
1966: } else if (!(st->flags & (ST_2FM_AT_EOD | ST_BLANK_READ))) {
1967: st->flags |= ST_BLANK_READ;
1968: xs->resid = xs->datalen;
1969: if (bp) {
1970: bp->b_resid = xs->resid;
1971: /* return an EOF */
1972: }
1973: return (0);
1974: }
1975: }
1976:
1977: return (EJUSTRETURN);
1978: }
1979:
1980: /*
1981: * The quirk here is that the drive returns some value to st_mode_sense
1982: * incorrectly until the tape has actually passed by the head.
1983: *
1984: * The method is to set the drive to large fixed-block state (user-specified
1985: * density and 1024-byte blocks), then read and rewind to get it to sense the
1986: * tape. If that doesn't work, try 512-byte fixed blocks. If that doesn't
1987: * work, as a last resort, try variable- length blocks. The result will be
1988: * the ability to do an accurate st_mode_sense.
1989: *
1990: * We know we can do a rewind because we just did a load, which implies rewind.
1991: * Rewind seems preferable to space backward if we have a virgin tape.
1992: *
1993: * The rest of the code for this quirk is in ILI processing and BLANK CHECK
1994: * error processing, both part of st_interpret_sense.
1995: */
1996: int
1997: st_touch_tape(st)
1998: struct st_softc *st;
1999: {
2000: char *buf;
2001: int readsize;
2002: int error;
2003:
2004: buf = malloc(1024, M_TEMP, M_NOWAIT);
2005: if (!buf)
2006: return ENOMEM;
2007:
2008: if ((error = st_mode_sense(st, 0)) != 0)
2009: goto bad;
2010: st->blksize = 1024;
2011: do {
2012: switch (st->blksize) {
2013: case 512:
2014: case 1024:
2015: readsize = st->blksize;
2016: st->flags |= ST_FIXEDBLOCKS;
2017: break;
2018: default:
2019: readsize = 1;
2020: st->flags &= ~ST_FIXEDBLOCKS;
2021: }
2022: if ((error = st_mode_select(st, 0)) != 0)
2023: goto bad;
2024: st_read(st, buf, readsize, SCSI_SILENT); /* XXX */
2025: if ((error = st_rewind(st, 0, 0)) != 0) {
2026: bad: free(buf, M_TEMP);
2027: return error;
2028: }
2029: } while (readsize != 1 && readsize > st->blksize);
2030:
2031: free(buf, M_TEMP);
2032: return 0;
2033: }
2034:
2035: int
2036: stdump(dev, blkno, va, size)
2037: dev_t dev;
2038: daddr64_t blkno;
2039: caddr_t va;
2040: size_t size;
2041: {
2042:
2043: /* Not implemented. */
2044: return ENXIO;
2045: }