Annotation of sys/arch/hp300/stand/common/sd.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: sd.c,v 1.6 2006/08/17 06:31:10 miod Exp $ */
! 2: /* $NetBSD: sd.c,v 1.9 1996/12/21 21:34:41 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1988 University of Utah.
! 6: * Copyright (c) 1990, 1993
! 7: * The Regents of the University of California. All rights reserved.
! 8: *
! 9: * This code is derived from software contributed to Berkeley by
! 10: * Van Jacobson of Lawrence Berkeley Laboratory and the Systems
! 11: * Programming Group of the University of Utah Computer Science Department.
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: * from: Utah $Hdr: sd.c 1.9 92/12/21$
! 38: *
! 39: * @(#)sd.c 8.1 (Berkeley) 6/10/93
! 40: */
! 41:
! 42: /*
! 43: * SCSI CCS disk driver
! 44: */
! 45:
! 46: #include <sys/param.h>
! 47: #include <sys/disklabel.h>
! 48:
! 49: #include <lib/libsa/stand.h>
! 50:
! 51: #include "samachdep.h"
! 52: #include "scsireg.h"
! 53:
! 54: struct disklabel sdlabel;
! 55:
! 56: struct sdminilabel {
! 57: u_short npart;
! 58: u_long offset[MAXPARTITIONS];
! 59: };
! 60:
! 61: struct sd_softc {
! 62: int sc_ctlr;
! 63: int sc_unit;
! 64: int sc_part;
! 65: char sc_retry;
! 66: char sc_alive;
! 67: short sc_blkshift;
! 68: struct sdminilabel sc_pinfo;
! 69: } sd_softc[NSCSI][NSD];
! 70:
! 71: #define SDRETRY 2
! 72:
! 73: int sdclose(struct open_file *);
! 74: int sdgetinfo(struct sd_softc *);
! 75: int sdinit(int, int);
! 76: int sdopen(struct open_file *, int, int, int);
! 77: void sdreset(int, int);
! 78: int sdstrategy(struct sd_softc *, int, daddr_t, size_t, void *, size_t *);
! 79:
! 80: int
! 81: sdinit(int ctlr, int unit)
! 82: {
! 83: struct sd_softc *ss = &sd_softc[ctlr][unit];
! 84: u_char stat;
! 85: int capbuf[2];
! 86:
! 87: stat = scsi_test_unit_rdy(ctlr, unit);
! 88: if (stat) {
! 89: /* drive may be doing RTZ - wait a bit */
! 90: if (stat == STS_CHECKCOND) {
! 91: DELAY(1000000);
! 92: stat = scsi_test_unit_rdy(ctlr, unit);
! 93: }
! 94: if (stat) {
! 95: printf("sd(%d,%d,0,0): init failed (stat=%x)\n",
! 96: ctlr, unit, stat);
! 97: return (0);
! 98: }
! 99: }
! 100: /*
! 101: * try to get the drive block size.
! 102: */
! 103: capbuf[0] = 0;
! 104: capbuf[1] = 0;
! 105: stat = scsi_read_capacity(ctlr, unit,
! 106: (u_char *)capbuf, sizeof(capbuf));
! 107: if (stat == 0) {
! 108: if (capbuf[1] > DEV_BSIZE)
! 109: for (; capbuf[1] > DEV_BSIZE; capbuf[1] >>= 1)
! 110: ++ss->sc_blkshift;
! 111: }
! 112: ss->sc_alive = 1;
! 113: return (1);
! 114: }
! 115:
! 116: void
! 117: sdreset(int ctlr, int unit)
! 118: {
! 119: }
! 120:
! 121: char io_buf[MAXBSIZE];
! 122:
! 123: int
! 124: sdgetinfo(struct sd_softc *ss)
! 125: {
! 126: struct sdminilabel *pi = &ss->sc_pinfo;
! 127: struct disklabel *lp = &sdlabel;
! 128: char *msg;
! 129: int err, savepart;
! 130: size_t i;
! 131:
! 132: bzero((caddr_t)lp, sizeof *lp);
! 133: lp->d_secsize = (DEV_BSIZE << ss->sc_blkshift);
! 134:
! 135: /* Disklabel is always from RAW_PART. */
! 136: savepart = ss->sc_part;
! 137: ss->sc_part = RAW_PART;
! 138: err = sdstrategy(ss, F_READ, LABELSECTOR,
! 139: lp->d_secsize ? lp->d_secsize : DEV_BSIZE, io_buf, &i);
! 140: ss->sc_part = savepart;
! 141:
! 142: if (err) {
! 143: printf("sdgetinfo: sdstrategy error %d\n", err);
! 144: return(0);
! 145: }
! 146:
! 147: msg = getdisklabel(io_buf, lp);
! 148: if (msg) {
! 149: printf("sd(%d,%d,%d): WARNING: %s, ",
! 150: ss->sc_ctlr, ss->sc_unit, ss->sc_part, msg);
! 151: printf("defining `c' partition as entire disk\n");
! 152: pi->npart = 3;
! 153: #ifdef CD9660_DUMMYLABEL
! 154: pi->offset[0] = 0;
! 155: lp->d_partitions[0].p_fstype = FS_ISO9660; /* just for kicks */
! 156: #else
! 157: pi->offset[0] = -1;
! 158: #endif
! 159: pi->offset[1] = -1;
! 160: pi->offset[2] = 0;
! 161: } else {
! 162: pi->npart = lp->d_npartitions;
! 163: for (i = 0; i < pi->npart; i++)
! 164: pi->offset[i] = lp->d_partitions[i].p_size == 0 ?
! 165: -1 : lp->d_partitions[i].p_offset;
! 166: }
! 167: return(1);
! 168: }
! 169:
! 170: int
! 171: sdopen(struct open_file *f, int ctlr, int unit, int part)
! 172: {
! 173: struct sd_softc *ss;
! 174:
! 175: #ifdef SD_DEBUG
! 176: if (debug)
! 177: printf("sdopen: ctlr=%d unit=%d part=%d\n",
! 178: ctlr, unit, part);
! 179: #endif
! 180:
! 181: if (ctlr >= NSCSI || scsialive(ctlr) == 0)
! 182: return (EADAPT);
! 183: if (unit >= NSD)
! 184: return (ECTLR);
! 185: ss = &sd_softc[ctlr][unit];
! 186: ss->sc_part = part;
! 187: ss->sc_unit = unit;
! 188: ss->sc_ctlr = ctlr;
! 189: if (ss->sc_alive == 0) {
! 190: if (sdinit(ctlr, unit) == 0)
! 191: return (ENXIO);
! 192: if (sdgetinfo(ss) == 0)
! 193: return (ERDLAB);
! 194: }
! 195: if (part != RAW_PART && /* always allow RAW_PART to be opened */
! 196: (part >= ss->sc_pinfo.npart || ss->sc_pinfo.offset[part] == -1))
! 197: return (EPART);
! 198: f->f_devdata = (void *)ss;
! 199: return (0);
! 200: }
! 201:
! 202: int
! 203: sdclose(struct open_file *f)
! 204: {
! 205: struct sd_softc *ss = f->f_devdata;
! 206:
! 207: /*
! 208: * Mark the disk `not alive' so that the disklabel
! 209: * will be re-loaded at next open.
! 210: */
! 211: bzero(ss, sizeof(sd_softc));
! 212: f->f_devdata = NULL;
! 213:
! 214: return (0);
! 215: }
! 216:
! 217: int
! 218: sdstrategy(struct sd_softc *ss, int func, daddr_t dblk, size_t size,
! 219: void *v_buf, size_t *rsize)
! 220: {
! 221: char *buf = v_buf;
! 222: int ctlr = ss->sc_ctlr;
! 223: int unit = ss->sc_unit;
! 224: u_int nblk = size >> ss->sc_blkshift;
! 225: daddr_t blk;
! 226: char stat;
! 227:
! 228: if (size == 0)
! 229: return(0);
! 230:
! 231: /*
! 232: * Don't do partition translation on the `raw partition'.
! 233: */
! 234: blk = (dblk + ((ss->sc_part == RAW_PART) ? 0 :
! 235: ss->sc_pinfo.offset[ss->sc_part])) >> ss->sc_blkshift;
! 236:
! 237: ss->sc_retry = 0;
! 238:
! 239: #ifdef SD_DEBUG
! 240: if (debug)
! 241: printf("sdstrategy(%d,%d): size=%d blk=%d nblk=%d\n",
! 242: ctlr, unit, size, blk, nblk);
! 243: #endif
! 244:
! 245: retry:
! 246: if (func == F_READ)
! 247: stat = scsi_tt_read(ctlr, unit, buf, size, blk, nblk);
! 248: else
! 249: stat = scsi_tt_write(ctlr, unit, buf, size, blk, nblk);
! 250: if (stat) {
! 251: printf("sd(%d,%d,%d): block=%x, error=0x%x\n",
! 252: ctlr, unit, ss->sc_part, blk, stat);
! 253: if (++ss->sc_retry > SDRETRY)
! 254: return(EIO);
! 255: goto retry;
! 256: }
! 257: *rsize = size;
! 258:
! 259: return(0);
! 260: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / stand / common