/* $NetBSD: sd.c,v 1.11.84.1 2024/06/22 10:57:10 martin Exp $ */ /* * Copyright (c) 1988 University of Utah. * Copyright (c) 1990, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Van Jacobson of Lawrence Berkeley Laboratory and the Systems * Programming Group of the University of Utah Computer Science Department. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: Utah $Hdr: sd.c 1.9 92/12/21$ * * @(#)sd.c 8.1 (Berkeley) 6/10/93 */ /* * SCSI CCS disk driver */ #include #include #include #include #include #define _IOCTL_ #include #include struct sdminilabel { u_short npart; u_long offset[MAXPARTITIONS]; }; struct sd_softc { int sc_ctlr; int sc_unit; int sc_part; char sc_retry; char sc_alive; short sc_blkshift; struct sdminilabel sc_pinfo; #ifdef SUPPORT_CD uint8_t sc_type; #endif }; #define SDRETRY 2 static int sdinit(int ,int); static int sdgetinfo(struct sd_softc *); struct disklabel sdlabel; struct sd_softc sd_softc[NSCSI][NSD]; static int sdinit(int ctlr, int unit) { struct sd_softc *ss = &sd_softc[ctlr][unit]; u_char stat; #ifdef SUPPORT_CD struct scsi_inquiry inqbuf; #endif int capbuf[2]; stat = scsi_test_unit_rdy(ctlr, unit); if (stat) { /* drive may be doing RTZ - wait a bit */ if (stat == STS_CHECKCOND) { DELAY(1000000); stat = scsi_test_unit_rdy(ctlr, unit); } if (stat) { printf("sd(%d,%d,0,0): init failed (stat=%x)\n", ctlr, unit, stat); return 0; } } #ifdef SUPPORT_CD /* * try to get the disk type. */ memset(&inqbuf, 0, sizeof(inqbuf)); stat = scsi_inquiry(ctlr, unit, (u_char *)&inqbuf, sizeof(inqbuf)); if (stat == 0) { /* to fake a disklabel on CD-ROM */ ss->sc_type = inqbuf.type & SID_TYPE; } else { /* assume a disk by default */ ss->sc_type = T_DIRECT; } #endif /* * try to get the drive block size. */ capbuf[0] = 0; capbuf[1] = 0; stat = scsi_read_capacity(ctlr, unit, (u_char *)capbuf, sizeof(capbuf)); if (stat == 0) { if (capbuf[1] > DEV_BSIZE) for (; capbuf[1] > DEV_BSIZE; capbuf[1] >>= 1) ++ss->sc_blkshift; } ss->sc_alive = 1; return 1; } char io_buf[MAXBSIZE]; static int sdgetinfo(struct sd_softc *ss) { struct sdminilabel *pi = &ss->sc_pinfo; struct disklabel *lp = &sdlabel; char *msg; int err, savepart; size_t i; memset((void *)lp, 0, sizeof *lp); lp->d_secsize = (DEV_BSIZE << ss->sc_blkshift); /* Disklabel is always from RAW_PART. */ savepart = ss->sc_part; ss->sc_part = RAW_PART; err = sdstrategy(ss, F_READ, LABELSECTOR, lp->d_secsize ? lp->d_secsize : DEV_BSIZE, io_buf, &i); ss->sc_part = savepart; if (err) { printf("sdgetinfo: sdstrategy error %d\n", err); return 0; } msg = getdisklabel(io_buf, lp); if (msg) { #ifdef SUPPORT_CD if (ss->sc_type == T_CDROM) { /* assume a whole disk region is ISO9660 */ pi->npart = 3; pi->offset[0] = 0; pi->offset[1] = -1; pi->offset[2] = 0; } else #endif { printf("sd(%d,%d,%d): WARNING: %s\n", ss->sc_ctlr, ss->sc_unit, ss->sc_part, msg); pi->npart = 3; pi->offset[0] = pi->offset[1] = -1; pi->offset[2] = 0; } } else { pi->npart = lp->d_npartitions; for (i = 0; i < pi->npart; i++) pi->offset[i] = lp->d_partitions[i].p_size == 0 ? -1 : lp->d_partitions[i].p_offset; } return 1; } int sdopen(struct open_file *f, ...) { va_list ap; int ctlr, unit, part; struct sd_softc *ss; va_start(ap, f); ctlr = va_arg(ap, int); unit = va_arg(ap, int); part = va_arg(ap, int); va_end(ap); #ifdef SD_DEBUG if (debug) printf("sdopen: ctlr=%d unit=%d part=%d\n", ctlr, unit, part); #endif if (ctlr >= NSCSI || scsialive(ctlr) == 0) return EADAPT; if (unit >= NSD) return ECTLR; ss = &sd_softc[ctlr][unit]; ss->sc_part = part; ss->sc_unit = unit; ss->sc_ctlr = ctlr; if (ss->sc_alive == 0) { if (sdinit(ctlr, unit) == 0) return ENXIO; if (sdgetinfo(ss) == 0) return ERDLAB; } if (part != RAW_PART && /* always allow RAW_PART to be opened */ (part >= ss->sc_pinfo.npart || ss->sc_pinfo.offset[part] == -1)) return EPART; f->f_devdata = (void *)ss; return 0; } int sdclose(struct open_file *f) { struct sd_softc *ss = f->f_devdata; /* * Mark the disk `not alive' so that the disklabel * will be re-loaded at next open. */ memset(ss, 0, sizeof(sd_softc)); f->f_devdata = NULL; return 0; } int sdstrategy(void *devdata, int func, daddr_t dblk, size_t size, void *v_buf, size_t *rsize) { struct sd_softc *ss = devdata; uint8_t *buf = v_buf; int ctlr = ss->sc_ctlr; int unit = ss->sc_unit; u_int nblk = size >> ss->sc_blkshift; daddr_t blk; int stat; if (size == 0) return 0; /* * Don't do partition translation on the `raw partition'. */ blk = (dblk + ((ss->sc_part == RAW_PART) ? 0 : ss->sc_pinfo.offset[ss->sc_part])) >> ss->sc_blkshift; ss->sc_retry = 0; #ifdef SD_DEBUG if (debug) printf("sdstrategy(%d,%d): size=%d blk=%d nblk=%d\n", ctlr, unit, size, blk, nblk); #endif retry: if (func == F_READ) stat = scsi_tt_read(ctlr, unit, buf, size, blk, nblk); else stat = scsi_tt_write(ctlr, unit, buf, size, blk, nblk); if (stat) { printf("sd(%d,%d,%d): block=%x, error=0x%x\n", ctlr, unit, ss->sc_part, blk, stat); if (++ss->sc_retry > SDRETRY) return EIO; goto retry; } *rsize = size; return 0; }