Return to cd.c CVS log

Up to [Net/2] / Net2 / arch / hp300 / dev

Annotation of Net2/arch/hp300/dev/cd.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1988 University of Utah.
        !             3:  * Copyright (c) 1990 The Regents of the University of California.
        !             4:  * All rights reserved.
        !             5:  *
        !             6:  * This code is derived from software contributed to Berkeley by
        !             7:  * the Systems Programming Group of the University of Utah Computer
        !             8:  * Science Department.
        !             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:  * 3. All advertising materials mentioning features or use of this software
        !            19:  *    must display the following acknowledgement:
        !            20:  *     This product includes software developed by the University of
        !            21:  *     California, Berkeley and its contributors.
        !            22:  * 4. Neither the name of the University nor the names of its contributors
        !            23:  *    may be used to endorse or promote products derived from this software
        !            24:  *    without specific prior written permission.
        !            25:  *
        !            26:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            27:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            28:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            29:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            30:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            31:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            32:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            33:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            34:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            35:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            36:  * SUCH DAMAGE.
        !            37:  *
        !            38:  * from: Utah $Hdr: cd.c 1.6 90/11/28$
        !            39:  *
        !            40:  *     @(#)cd.c        7.4 (Berkeley) 5/7/91
        !            41:  */
        !            42: 
        !            43: /*
        !            44:  * "Concatenated" disk driver.
        !            45:  */
        !            46: #include "cd.h"
        !            47: #if NCD > 0
        !            48: 
        !            49: #include "sys/param.h"
        !            50: #include "sys/systm.h"
        !            51: #include "sys/errno.h"
        !            52: #include "sys/dkstat.h"
        !            53: #include "sys/buf.h"
        !            54: #include "sys/malloc.h"
        !            55: #include "sys/conf.h"
        !            56: 
        !            57: #include "cdvar.h"
        !            58: 
        !            59: #ifdef DEBUG
        !            60: int cddebug = 0x00;
        !            61: #define CDB_FOLLOW     0x01
        !            62: #define CDB_INIT       0x02
        !            63: #define CDB_IO         0x04
        !            64: #endif
        !            65: 
        !            66: struct buf cdbuf[NCD];
        !            67: struct buf *cdbuffer();
        !            68: char   *cddevtostr();
        !            69: int    cdiodone();
        !            70: 
        !            71: #define        cdunit(x)       ((minor(x) >> 3) & 0x7) /* for consistency */
        !            72: 
        !            73: #define        getcbuf()       \
        !            74:        ((struct buf *)malloc(sizeof(struct buf), M_DEVBUF, M_WAITOK))
        !            75: #define putcbuf(bp)    \
        !            76:        free((caddr_t)(bp), M_DEVBUF)
        !            77: 
        !            78: struct cd_softc {
        !            79:        int              sc_flags;              /* flags */
        !            80:        size_t           sc_size;               /* size of cd */
        !            81:        int              sc_ileave;             /* interleave */
        !            82:        int              sc_ncdisks;            /* number of components */
        !            83:        struct cdcinfo   sc_cinfo[NCDISKS];     /* component info */
        !            84:        struct cdiinfo   *sc_itable;            /* interleave table */
        !            85:        int              sc_usecnt;             /* number of requests active */
        !            86:        struct buf       *sc_bp;                /* "current" request */
        !            87:        int              sc_dk;                 /* disk index */
        !            88: } cd_softc[NCD];
        !            89: 
        !            90: /* sc_flags */
        !            91: #define        CDF_ALIVE       0x01
        !            92: #define CDF_INITED     0x02
        !            93: 
        !            94: cdinit(cd)
        !            95:        struct cddevice *cd;
        !            96: {
        !            97:        register struct cd_softc *cs = &cd_softc[cd->cd_unit];
        !            98:        register struct cdcinfo *ci;
        !            99:        register size_t size;
        !           100:        register int ix;
        !           101:        size_t minsize;
        !           102:        dev_t dev;
        !           103: 
        !           104: #ifdef DEBUG
        !           105:        if (cddebug & (CDB_FOLLOW|CDB_INIT))
        !           106:                printf("cdinit: unit %d\n", cd->cd_unit);
        !           107: #endif
        !           108:        cs->sc_dk = cd->cd_dk;
        !           109:        cs->sc_size = 0;
        !           110:        cs->sc_ileave = cd->cd_interleave;
        !           111:        cs->sc_ncdisks = 0;
        !           112:        /*
        !           113:         * Verify that each component piece exists and record
        !           114:         * relevant information about it.
        !           115:         */
        !           116:        minsize = 0;
        !           117:        for (ix = 0; ix < NCDISKS; ix++) {
        !           118:                if ((dev = cd->cd_dev[ix]) == NODEV)
        !           119:                        break;
        !           120:                ci = &cs->sc_cinfo[ix];
        !           121:                ci->ci_dev = dev;
        !           122:                /*
        !           123:                 * Calculate size (truncated to interleave boundary
        !           124:                 * if necessary.
        !           125:                 */
        !           126:                if (bdevsw[major(dev)].d_psize) {
        !           127:                        size = (size_t) (*bdevsw[major(dev)].d_psize)(dev);
        !           128:                        if ((int)size < 0)
        !           129:                                size = 0;
        !           130:                } else
        !           131:                        size = 0;
        !           132:                if (cs->sc_ileave > 1)
        !           133:                        size -= size % cs->sc_ileave;
        !           134:                if (size == 0) {
        !           135:                        printf("cd%d: not configured (component %s missing)\n",
        !           136:                               cd->cd_unit, cddevtostr(ci->ci_dev));
        !           137:                        return(0);
        !           138:                }
        !           139:                if (minsize == 0 || size < minsize)
        !           140:                        minsize = size;
        !           141:                ci->ci_size = size;
        !           142:                cs->sc_size += size;
        !           143:                cs->sc_ncdisks++;
        !           144:        }
        !           145:        /*
        !           146:         * If uniform interleave is desired set all sizes to that of
        !           147:         * the smallest component.
        !           148:         */
        !           149:        if (cd->cd_flags & CDF_UNIFORM) {
        !           150:                for (ci = cs->sc_cinfo;
        !           151:                     ci < &cs->sc_cinfo[cs->sc_ncdisks]; ci++)
        !           152:                        ci->ci_size = minsize;
        !           153:                cs->sc_size = cs->sc_ncdisks * minsize;
        !           154:        }
        !           155:        /*
        !           156:         * Construct the interleave table
        !           157:         */
        !           158:        if (!cdinterleave(cs))
        !           159:                return(0);
        !           160:        if (cd->cd_dk >= 0)
        !           161:                dk_wpms[cd->cd_dk] = 32 * (60 * DEV_BSIZE / 2); /* XXX */
        !           162:        printf("cd%d: %d components ", cd->cd_unit, cs->sc_ncdisks);
        !           163:        for (ix = 0; ix < cs->sc_ncdisks; ix++)
        !           164:                printf("%c%s%c",
        !           165:                       ix == 0 ? '(' : ' ',
        !           166:                       cddevtostr(cs->sc_cinfo[ix].ci_dev),
        !           167:                       ix == cs->sc_ncdisks - 1 ? ')' : ',');
        !           168:        printf(", %d blocks ", cs->sc_size);
        !           169:        if (cs->sc_ileave)
        !           170:                printf("interleaved at %d blocks\n", cs->sc_ileave);
        !           171:        else
        !           172:                printf("concatenated\n");
        !           173:        cs->sc_flags = CDF_ALIVE | CDF_INITED;
        !           174:        return(1);
        !           175: }
        !           176: 
        !           177: /*
        !           178:  * XXX not really cd specific.
        !           179:  */
        !           180: char *
        !           181: cddevtostr(dev)
        !           182:        dev_t dev;
        !           183: {
        !           184:        static char dbuf[5];
        !           185: 
        !           186:        dbuf[1] = 'd';
        !           187:        switch (major(dev)) {
        !           188:        case 2:
        !           189:                dbuf[0] = 'r';
        !           190:                break;
        !           191:        case 4:
        !           192:                dbuf[0] = 's';
        !           193:                break;
        !           194:        case 5:
        !           195:                dbuf[0] = 'c';
        !           196:                break;
        !           197:        default:
        !           198:                dbuf[0] = dbuf[1] = '?';
        !           199:                break;
        !           200:        }
        !           201:        dbuf[2] = (minor(dev) >> 3) + '0';
        !           202:        dbuf[3] = (minor(dev) & 7) + 'a';
        !           203:        dbuf[4] = '\0';
        !           204:        return (dbuf);
        !           205: }
        !           206: 
        !           207: cdinterleave(cs)
        !           208:        register struct cd_softc *cs;
        !           209: {
        !           210:        register struct cdcinfo *ci, *smallci;
        !           211:        register struct cdiinfo *ii;
        !           212:        register daddr_t bn, lbn;
        !           213:        register int ix;
        !           214:        u_long size;
        !           215: 
        !           216: #ifdef DEBUG
        !           217:        if (cddebug & CDB_INIT)
        !           218:                printf("cdinterleave(%x): ileave %d\n", cs, cs->sc_ileave);
        !           219: #endif
        !           220:        /*
        !           221:         * Allocate an interleave table.
        !           222:         * Chances are this is too big, but we don't care.
        !           223:         */
        !           224:        size = (cs->sc_ncdisks + 1) * sizeof(struct cdiinfo);
        !           225:        cs->sc_itable = (struct cdiinfo *)malloc(size, M_DEVBUF, M_WAITOK);
        !           226:        bzero((caddr_t)cs->sc_itable, size);
        !           227:        /*
        !           228:         * Trivial case: no interleave (actually interleave of disk size).
        !           229:         * Each table entry represent a single component in its entirety.
        !           230:         */
        !           231:        if (cs->sc_ileave == 0) {
        !           232:                bn = 0;
        !           233:                ii = cs->sc_itable;
        !           234:                for (ix = 0; ix < cs->sc_ncdisks; ix++) {
        !           235:                        ii->ii_ndisk = 1;
        !           236:                        ii->ii_startblk = bn;
        !           237:                        ii->ii_startoff = 0;
        !           238:                        ii->ii_index[0] = ix;
        !           239:                        bn += cs->sc_cinfo[ix].ci_size;
        !           240:                        ii++;
        !           241:                }
        !           242:                ii->ii_ndisk = 0;
        !           243: #ifdef DEBUG
        !           244:                if (cddebug & CDB_INIT)
        !           245:                        printiinfo(cs->sc_itable);
        !           246: #endif
        !           247:                return(1);
        !           248:        }
        !           249:        /*
        !           250:         * The following isn't fast or pretty; it doesn't have to be.
        !           251:         */
        !           252:        size = 0;
        !           253:        bn = lbn = 0;
        !           254:        for (ii = cs->sc_itable; ; ii++) {
        !           255:                /*
        !           256:                 * Locate the smallest of the remaining components
        !           257:                 */
        !           258:                smallci = NULL;
        !           259:                for (ci = cs->sc_cinfo;
        !           260:                     ci < &cs->sc_cinfo[cs->sc_ncdisks]; ci++)
        !           261:                        if (ci->ci_size > size &&
        !           262:                            (smallci == NULL ||
        !           263:                             ci->ci_size < smallci->ci_size))
        !           264:                                smallci = ci;
        !           265:                /*
        !           266:                 * Nobody left, all done
        !           267:                 */
        !           268:                if (smallci == NULL) {
        !           269:                        ii->ii_ndisk = 0;
        !           270:                        break;
        !           271:                }
        !           272:                /*
        !           273:                 * Record starting logical block and component offset
        !           274:                 */
        !           275:                ii->ii_startblk = bn / cs->sc_ileave;
        !           276:                ii->ii_startoff = lbn;
        !           277:                /*
        !           278:                 * Determine how many disks take part in this interleave
        !           279:                 * and record their indices.
        !           280:                 */
        !           281:                ix = 0;
        !           282:                for (ci = cs->sc_cinfo;
        !           283:                     ci < &cs->sc_cinfo[cs->sc_ncdisks]; ci++)
        !           284:                        if (ci->ci_size >= smallci->ci_size)
        !           285:                                ii->ii_index[ix++] = ci - cs->sc_cinfo;
        !           286:                ii->ii_ndisk = ix;
        !           287:                bn += ix * (smallci->ci_size - size);
        !           288:                lbn = smallci->ci_size / cs->sc_ileave;
        !           289:                size = smallci->ci_size;
        !           290:        }
        !           291: #ifdef DEBUG
        !           292:        if (cddebug & CDB_INIT)
        !           293:                printiinfo(cs->sc_itable);
        !           294: #endif
        !           295:        return(1);
        !           296: }
        !           297: 
        !           298: #ifdef DEBUG
        !           299: printiinfo(ii)
        !           300:        struct cdiinfo *ii;
        !           301: {
        !           302:        register int ix, i;
        !           303: 
        !           304:        for (ix = 0; ii->ii_ndisk; ix++, ii++) {
        !           305:                printf(" itab[%d]: #dk %d sblk %d soff %d",
        !           306:                       ix, ii->ii_ndisk, ii->ii_startblk, ii->ii_startoff);
        !           307:                for (i = 0; i < ii->ii_ndisk; i++)
        !           308:                        printf(" %d", ii->ii_index[i]);
        !           309:                printf("\n");
        !           310:        }
        !           311: }
        !           312: #endif
        !           313: 
        !           314: cdopen(dev, flags)
        !           315:        dev_t dev;
        !           316: {
        !           317:        int unit = cdunit(dev);
        !           318:        register struct cd_softc *cs = &cd_softc[unit];
        !           319: 
        !           320: #ifdef DEBUG
        !           321:        if (cddebug & CDB_FOLLOW)
        !           322:                printf("cdopen(%x, %x)\n", dev, flags);
        !           323: #endif
        !           324:        if (unit >= NCD || (cs->sc_flags & CDF_ALIVE) == 0)
        !           325:                return(ENXIO);
        !           326:        return(0);
        !           327: }
        !           328: 
        !           329: cdstrategy(bp)
        !           330:        register struct buf *bp;
        !           331: {
        !           332:        register int unit = cdunit(bp->b_dev);
        !           333:        register struct cd_softc *cs = &cd_softc[unit];
        !           334:        register daddr_t bn;
        !           335:        register int sz, s;
        !           336: 
        !           337: #ifdef DEBUG
        !           338:        if (cddebug & CDB_FOLLOW)
        !           339:                printf("cdstrategy(%x): unit %d\n", bp, unit);
        !           340: #endif
        !           341:        if ((cs->sc_flags & CDF_INITED) == 0) {
        !           342:                bp->b_error = ENXIO;
        !           343:                bp->b_flags |= B_ERROR;
        !           344:                goto done;
        !           345:        }
        !           346:        bn = bp->b_blkno;
        !           347:        sz = howmany(bp->b_bcount, DEV_BSIZE);
        !           348:        if (bn < 0 || bn + sz > cs->sc_size) {
        !           349:                sz = cs->sc_size - bn;
        !           350:                if (sz == 0) {
        !           351:                        bp->b_resid = bp->b_bcount;
        !           352:                        goto done;
        !           353:                }
        !           354:                if (sz < 0) {
        !           355:                        bp->b_error = EINVAL;
        !           356:                        bp->b_flags |= B_ERROR;
        !           357:                        goto done;
        !           358:                }
        !           359:                bp->b_bcount = dbtob(sz);
        !           360:        }
        !           361:        bp->b_resid = bp->b_bcount;
        !           362:        /*
        !           363:         * "Start" the unit.
        !           364:         * XXX: the use of sc_bp is just to retain the "traditional"
        !           365:         * interface to the start routine.
        !           366:         */
        !           367:        s = splbio();
        !           368:        cs->sc_bp = bp;
        !           369:        cdstart(unit);
        !           370:        splx(s);
        !           371:        return;
        !           372: done:
        !           373:        biodone(bp);
        !           374: }
        !           375: 
        !           376: cdstart(unit)
        !           377:        int unit;
        !           378: {
        !           379:        register struct cd_softc *cs = &cd_softc[unit];
        !           380:        register struct buf *bp = cs->sc_bp;
        !           381:        register long bcount, rcount;
        !           382:        struct buf *cbp;
        !           383:        caddr_t addr;
        !           384:        daddr_t bn;
        !           385: 
        !           386: #ifdef DEBUG
        !           387:        if (cddebug & CDB_FOLLOW)
        !           388:                printf("cdstart(%d)\n", unit);
        !           389: #endif
        !           390:        /*
        !           391:         * Instumentation (not real meaningful)
        !           392:         */
        !           393:        cs->sc_usecnt++;
        !           394:        if (cs->sc_dk >= 0) {
        !           395:                dk_busy |= 1 << cs->sc_dk;
        !           396:                dk_xfer[cs->sc_dk]++;
        !           397:                dk_wds[cs->sc_dk] += bp->b_bcount >> 6;
        !           398:        }
        !           399:        /*
        !           400:         * Allocate component buffers and fire off the requests
        !           401:         */
        !           402:        bn = bp->b_blkno;
        !           403:        addr = bp->b_un.b_addr;
        !           404:        for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
        !           405:                cbp = cdbuffer(cs, bp, bn, addr, bcount);
        !           406:                rcount = cbp->b_bcount;
        !           407:                (*bdevsw[major(cbp->b_dev)].d_strategy)(cbp);
        !           408:                bn += btodb(rcount);
        !           409:                addr += rcount;
        !           410:        }
        !           411: }
        !           412: 
        !           413: /*
        !           414:  * Build a component buffer header.
        !           415:  */
        !           416: struct buf *
        !           417: cdbuffer(cs, bp, bn, addr, bcount)
        !           418:        register struct cd_softc *cs;
        !           419:        struct buf *bp;
        !           420:        daddr_t bn;
        !           421:        caddr_t addr;
        !           422:        long bcount;
        !           423: {
        !           424:        register struct cdcinfo *ci;
        !           425:        register struct buf *cbp;
        !           426:        register daddr_t cbn, cboff;
        !           427: 
        !           428: #ifdef DEBUG
        !           429:        if (cddebug & CDB_IO)
        !           430:                printf("cdbuffer(%x, %x, %d, %x, %d)\n",
        !           431:                       cs, bp, bn, addr, bcount);
        !           432: #endif
        !           433:        /*
        !           434:         * Determine which component bn falls in.
        !           435:         */
        !           436:        cbn = bn;
        !           437:        cboff = 0;
        !           438:        /*
        !           439:         * Serially concatenated
        !           440:         */
        !           441:        if (cs->sc_ileave == 0) {
        !           442:                register daddr_t sblk;
        !           443: 
        !           444:                sblk = 0;
        !           445:                for (ci = cs->sc_cinfo; cbn >= sblk + ci->ci_size; ci++)
        !           446:                        sblk += ci->ci_size;
        !           447:                cbn -= sblk;
        !           448:        }
        !           449:        /*
        !           450:         * Interleaved
        !           451:         */
        !           452:        else {
        !           453:                register struct cdiinfo *ii;
        !           454:                int cdisk, off;
        !           455: 
        !           456:                cboff = cbn % cs->sc_ileave;
        !           457:                cbn /= cs->sc_ileave;
        !           458:                for (ii = cs->sc_itable; ii->ii_ndisk; ii++)
        !           459:                        if (ii->ii_startblk > cbn)
        !           460:                                break;
        !           461:                ii--;
        !           462:                off = cbn - ii->ii_startblk;
        !           463:                if (ii->ii_ndisk == 1) {
        !           464:                        cdisk = ii->ii_index[0];
        !           465:                        cbn = ii->ii_startoff + off;
        !           466:                } else {
        !           467:                        cdisk = ii->ii_index[off % ii->ii_ndisk];
        !           468:                        cbn = ii->ii_startoff + off / ii->ii_ndisk;
        !           469:                }
        !           470:                cbn *= cs->sc_ileave;
        !           471:                ci = &cs->sc_cinfo[cdisk];
        !           472:        }
        !           473:        /*
        !           474:         * Fill in the component buf structure.
        !           475:         */
        !           476:        cbp = getcbuf();
        !           477:        cbp->b_flags = bp->b_flags | B_CALL;
        !           478:        cbp->b_iodone = cdiodone;
        !           479:        cbp->b_proc = bp->b_proc;
        !           480:        cbp->b_dev = ci->ci_dev;
        !           481:        cbp->b_blkno = cbn + cboff;
        !           482:        cbp->b_un.b_addr = addr;
        !           483:        cbp->b_vp = 0;
        !           484:        if (cs->sc_ileave == 0)
        !           485:                cbp->b_bcount = dbtob(ci->ci_size - cbn);
        !           486:        else
        !           487:                cbp->b_bcount = dbtob(cs->sc_ileave - cboff);
        !           488:        if (cbp->b_bcount > bcount)
        !           489:                cbp->b_bcount = bcount;
        !           490:        /*
        !           491:         * XXX: context for cdiodone
        !           492:         */
        !           493:        cbp->b_saveaddr = (caddr_t)bp;
        !           494:        cbp->b_pfcent = ((cs - cd_softc) << 16) | (ci - cs->sc_cinfo);
        !           495: #ifdef DEBUG
        !           496:        if (cddebug & CDB_IO)
        !           497:                printf(" dev %x(u%d): cbp %x bn %d addr %x bcnt %d\n",
        !           498:                       ci->ci_dev, ci-cs->sc_cinfo, cbp, cbp->b_blkno,
        !           499:                       cbp->b_un.b_addr, cbp->b_bcount);
        !           500: #endif
        !           501:        return(cbp);
        !           502: }
        !           503: 
        !           504: cdintr(unit)
        !           505:        int unit;
        !           506: {
        !           507:        register struct cd_softc *cs = &cd_softc[unit];
        !           508:        register struct buf *bp = cs->sc_bp;
        !           509: 
        !           510: #ifdef DEBUG
        !           511:        if (cddebug & CDB_FOLLOW)
        !           512:                printf("cdintr(%d): bp %x\n", unit, bp);
        !           513: #endif
        !           514:        /*
        !           515:         * Request is done for better or worse, wakeup the top half.
        !           516:         */
        !           517:        if (--cs->sc_usecnt == 0 && cs->sc_dk >= 0)
        !           518:                dk_busy &= ~(1 << cs->sc_dk);
        !           519:        if (bp->b_flags & B_ERROR)
        !           520:                bp->b_resid = bp->b_bcount;
        !           521:        biodone(bp);
        !           522: }
        !           523: 
        !           524: /*
        !           525:  * Called by biodone at interrupt time.
        !           526:  * Mark the component as done and if all components are done,
        !           527:  * take a cd interrupt.
        !           528:  */
        !           529: cdiodone(cbp)
        !           530:        register struct buf *cbp;
        !           531: {
        !           532:        register struct buf *bp = (struct buf *)cbp->b_saveaddr;/* XXX */
        !           533:        register int unit = (cbp->b_pfcent >> 16) & 0xFFFF;     /* XXX */
        !           534:        int count, s;
        !           535: 
        !           536:        s = splbio();
        !           537: #ifdef DEBUG
        !           538:        if (cddebug & CDB_FOLLOW)
        !           539:                printf("cdiodone(%x)\n", cbp);
        !           540:        if (cddebug & CDB_IO) {
        !           541:                printf("cdiodone: bp %x bcount %d resid %d\n",
        !           542:                       bp, bp->b_bcount, bp->b_resid);
        !           543:                printf(" dev %x(u%d), cbp %x bn %d addr %x bcnt %d\n",
        !           544:                       cbp->b_dev, cbp->b_pfcent & 0xFFFF, cbp,
        !           545:                       cbp->b_blkno, cbp->b_un.b_addr, cbp->b_bcount);
        !           546:        }
        !           547: #endif
        !           548: 
        !           549:        if (cbp->b_flags & B_ERROR) {
        !           550:                bp->b_flags |= B_ERROR;
        !           551:                bp->b_error = biowait(cbp);
        !           552: #ifdef DEBUG
        !           553:                printf("cd%d: error %d on component %d\n",
        !           554:                       unit, bp->b_error, cbp->b_pfcent & 0xFFFF);
        !           555: #endif
        !           556:        }
        !           557:        count = cbp->b_bcount;
        !           558:        putcbuf(cbp);
        !           559: 
        !           560:        /*
        !           561:         * If all done, "interrupt".
        !           562:         * Again, sc_bp is only used to preserve the traditional interface.
        !           563:         */
        !           564:        bp->b_resid -= count;
        !           565:        if (bp->b_resid < 0)
        !           566:                panic("cdiodone: count");
        !           567:        if (bp->b_resid == 0) {
        !           568:                cd_softc[unit].sc_bp = bp;
        !           569:                cdintr(unit);
        !           570:        }
        !           571:        splx(s);
        !           572: }
        !           573: 
        !           574: cdread(dev, uio)
        !           575:        dev_t dev;
        !           576:        struct uio *uio;
        !           577: {
        !           578:        register int unit = cdunit(dev);
        !           579: 
        !           580: #ifdef DEBUG
        !           581:        if (cddebug & CDB_FOLLOW)
        !           582:                printf("cdread(%x, %x)\n", dev, uio);
        !           583: #endif
        !           584:        return(physio(cdstrategy, &cdbuf[unit], dev, B_READ, minphys, uio));
        !           585: }
        !           586: 
        !           587: cdwrite(dev, uio)
        !           588:        dev_t dev;
        !           589:        struct uio *uio;
        !           590: {
        !           591:        register int unit = cdunit(dev);
        !           592: 
        !           593: #ifdef DEBUG
        !           594:        if (cddebug & CDB_FOLLOW)
        !           595:                printf("cdwrite(%x, %x)\n", dev, uio);
        !           596: #endif
        !           597:        return(physio(cdstrategy, &cdbuf[unit], dev, B_WRITE, minphys, uio));
        !           598: }
        !           599: 
        !           600: cdioctl(dev, cmd, data, flag)
        !           601:        dev_t dev;
        !           602:        int cmd;
        !           603:        caddr_t data;
        !           604:        int flag;
        !           605: {
        !           606:        return(EINVAL);
        !           607: }
        !           608: 
        !           609: cdsize(dev)
        !           610:        dev_t dev;
        !           611: {
        !           612:        int unit = cdunit(dev);
        !           613:        register struct cd_softc *cs = &cd_softc[unit];
        !           614: 
        !           615:        if (unit >= NCD || (cs->sc_flags & CDF_INITED) == 0)
        !           616:                return(-1);
        !           617:        return(cs->sc_size);
        !           618: }
        !           619: 
        !           620: cddump(dev)
        !           621: {
        !           622:        return(ENXIO);
        !           623: }
        !           624: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.