Return to uda.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba

Annotation of 43BSDTahoe/sys/vaxuba/uda.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1988 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * This code is derived from software contributed to Berkeley by
        !             6:  * Chris Torek.
        !             7:  *
        !             8:  * Redistribution and use in source and binary forms are permitted
        !             9:  * provided that the above copyright notice and this paragraph are
        !            10:  * duplicated in all such forms and that any documentation,
        !            11:  * advertising materials, and other materials related to such
        !            12:  * distribution and use acknowledge that the software was developed
        !            13:  * by the University of California, Berkeley.  The name of the
        !            14:  * University may not be used to endorse or promote products derived
        !            15:  * from this software without specific prior written permission.
        !            16:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
        !            17:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
        !            18:  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !            19:  *
        !            20:  *     @(#)uda.c       7.19 (Berkeley) 7/9/88
        !            21:  */
        !            22: 
        !            23: /*
        !            24:  * UDA50/MSCP device driver
        !            25:  */
        !            26: 
        !            27: #define        POLLSTATS
        !            28: 
        !            29: /*
        !            30:  * TODO
        !            31:  *     write bad block forwarding code
        !            32:  */
        !            33: 
        !            34: #include "ra.h"
        !            35: 
        !            36: #if NUDA > 0
        !            37: 
        !            38: /*
        !            39:  * CONFIGURATION OPTIONS.  The next three defines are tunable -- tune away!
        !            40:  *
        !            41:  * COMPAT_42 enables 4.2/4.3 compatibility (label mapping)
        !            42:  *
        !            43:  * NRSPL2 and NCMDL2 control the number of response and command
        !            44:  * packets respectively.  They may be any value from 0 to 7, though
        !            45:  * setting them higher than 5 is unlikely to be of any value.
        !            46:  * If you get warnings about your command ring being too small,
        !            47:  * try increasing the values by one.
        !            48:  *
        !            49:  * MAXUNIT controls the maximum unit number (number of drives per
        !            50:  * controller) we are prepared to handle.
        !            51:  *
        !            52:  * DEFAULT_BURST must be at least 1.
        !            53:  */
        !            54: #define        COMPAT_42
        !            55: 
        !            56: #define        NRSPL2  5               /* log2 number of response packets */
        !            57: #define NCMDL2 5               /* log2 number of command packets */
        !            58: #define        MAXUNIT 8               /* maximum allowed unit number */
        !            59: #define        DEFAULT_BURST   4       /* default DMA burst size */
        !            60: 
        !            61: #include "param.h"
        !            62: #include "systm.h"
        !            63: #include "buf.h"
        !            64: #include "conf.h"
        !            65: #include "dir.h"
        !            66: #include "file.h"
        !            67: #include "ioctl.h"
        !            68: #include "user.h"
        !            69: #include "map.h"
        !            70: #include "vm.h"
        !            71: #include "dkstat.h"
        !            72: #include "cmap.h"
        !            73: #include "disklabel.h"
        !            74: #include "syslog.h"
        !            75: #include "stat.h"
        !            76: 
        !            77: #include "../machine/pte.h"
        !            78: 
        !            79: #include "../vax/cpu.h"
        !            80: #include "ubareg.h"
        !            81: #include "ubavar.h"
        !            82: 
        !            83: #define        NRSP    (1 << NRSPL2)
        !            84: #define        NCMD    (1 << NCMDL2)
        !            85: 
        !            86: #include "udareg.h"
        !            87: #include "../vax/mscp.h"
        !            88: #include "../vax/mscpvar.h"
        !            89: #include "../vax/mtpr.h"
        !            90: 
        !            91: /*
        !            92:  * UDA communications area and MSCP packet pools, per controller.
        !            93:  */
        !            94: struct uda {
        !            95:        struct  udaca uda_ca;           /* communications area */
        !            96:        struct  mscp uda_rsp[NRSP];     /* response packets */
        !            97:        struct  mscp uda_cmd[NCMD];     /* command packets */
        !            98: } uda[NUDA];
        !            99: 
        !           100: /*
        !           101:  * Software status, per controller.
        !           102:  */
        !           103: struct uda_softc {
        !           104:        struct  uda *sc_uda;    /* Unibus address of uda struct */
        !           105:        short   sc_state;       /* UDA50 state; see below */
        !           106:        short   sc_flags;       /* flags; see below */
        !           107:        int     sc_micro;       /* microcode revision */
        !           108:        int     sc_ivec;        /* interrupt vector address */
        !           109:        struct  mscp_info sc_mi;/* MSCP info (per mscpvar.h) */
        !           110: #ifndef POLLSTATS
        !           111:        int     sc_wticks;      /* watchdog timer ticks */
        !           112: #else
        !           113:        short   sc_wticks;
        !           114:        short   sc_ncmd;
        !           115: #endif
        !           116: } uda_softc[NUDA];
        !           117: 
        !           118: #ifdef POLLSTATS
        !           119: struct udastats {
        !           120:        int     ncmd;
        !           121:        int     cmd[NCMD + 1];
        !           122: } udastats = { NCMD + 1 };
        !           123: #endif
        !           124: 
        !           125: /*
        !           126:  * Controller states
        !           127:  */
        !           128: #define        ST_IDLE         0       /* uninitialised */
        !           129: #define        ST_STEP1        1       /* in `STEP 1' */
        !           130: #define        ST_STEP2        2       /* in `STEP 2' */
        !           131: #define        ST_STEP3        3       /* in `STEP 3' */
        !           132: #define        ST_SETCHAR      4       /* in `Set Controller Characteristics' */
        !           133: #define        ST_RUN          5       /* up and running */
        !           134: 
        !           135: /*
        !           136:  * Flags
        !           137:  */
        !           138: #define        SC_MAPPED       0x01    /* mapped in Unibus I/O space */
        !           139: #define        SC_INSTART      0x02    /* inside udastart() */
        !           140: #define        SC_GRIPED       0x04    /* griped about cmd ring too small */
        !           141: #define        SC_INSLAVE      0x08    /* inside udaslave() */
        !           142: #define        SC_DOWAKE       0x10    /* wakeup when ctlr init done */
        !           143: #define        SC_STARTPOLL    0x20    /* need to initiate polling */
        !           144: 
        !           145: /*
        !           146:  * Device to unit number and partition and back
        !           147:  */
        !           148: #define        UNITSHIFT       3
        !           149: #define        UNITMASK        7
        !           150: #define        udaunit(dev)    (minor(dev) >> UNITSHIFT)
        !           151: #define        udapart(dev)    (minor(dev) & UNITMASK)
        !           152: #define        udaminor(u, p)  (((u) << UNITSHIFT) | (p))
        !           153: 
        !           154: /*
        !           155:  * Drive status, per drive
        !           156:  */
        !           157: struct ra_info {
        !           158:        daddr_t ra_dsize;       /* size in sectors */
        !           159: /*     u_long  ra_type;        /* drive type */
        !           160:        u_long  ra_mediaid;     /* media id */
        !           161:        int     ra_state;       /* open/closed state */
        !           162:        struct  ra_geom {       /* geometry information */
        !           163:                u_short rg_nsectors;    /* sectors/track */
        !           164:                u_short rg_ngroups;     /* track groups */
        !           165:                u_short rg_ngpc;        /* groups/cylinder */
        !           166:                u_short rg_ntracks;     /* ngroups*ngpc */
        !           167:                u_short rg_ncyl;        /* ra_dsize/ntracks/nsectors */
        !           168: #ifdef notyet
        !           169:                u_short rg_rctsize;     /* size of rct */
        !           170:                u_short rg_rbns;        /* replacement blocks per track */
        !           171:                u_short rg_nrct;        /* number of rct copies */
        !           172: #endif
        !           173:        } ra_geom;
        !           174:        int     ra_wlabel;      /* label sector is currently writable */
        !           175:        u_long  ra_openpart;    /* partitions open */
        !           176:        u_long  ra_bopenpart;   /* block partitions open */
        !           177:        u_long  ra_copenpart;   /* character partitions open */
        !           178: } ra_info[NRA];
        !           179: 
        !           180: /*
        !           181:  * Software state, per drive
        !           182:  */
        !           183: #define        CLOSED          0
        !           184: #define        WANTOPEN        1
        !           185: #define        RDLABEL         2
        !           186: #define        OPEN            3
        !           187: #define        OPENRAW         4
        !           188: 
        !           189: /*
        !           190:  * Definition of the driver for autoconf.
        !           191:  */
        !           192: int    udaprobe(), udaslave(), udaattach(), udadgo(), udaintr();
        !           193: struct uba_ctlr *udaminfo[NUDA];
        !           194: struct uba_device *udadinfo[NRA];
        !           195: struct disklabel udalabel[NRA];
        !           196: 
        !           197: u_short        udastd[] = { 0772150, 0772550, 0777550, 0 };
        !           198: struct uba_driver udadriver =
        !           199:  { udaprobe, udaslave, udaattach, udadgo, udastd, "ra", udadinfo, "uda",
        !           200:    udaminfo };
        !           201: 
        !           202: /*
        !           203:  * More driver definitions, for generic MSCP code.
        !           204:  */
        !           205: int    udadgram(), udactlrdone(), udaunconf(), udaiodone();
        !           206: int    udaonline(), udagotstatus(), udaioerror(), udareplace(), udabb();
        !           207: 
        !           208: struct buf udautab[NRA];       /* per drive transfer queue */
        !           209: 
        !           210: struct mscp_driver udamscpdriver =
        !           211:  { MAXUNIT, NRA, UNITSHIFT, udautab, udalabel, udadinfo,
        !           212:    udadgram, udactlrdone, udaunconf, udaiodone,
        !           213:    udaonline, udagotstatus, udareplace, udaioerror, udabb,
        !           214:    "uda", "ra" };
        !           215: 
        !           216: /*
        !           217:  * Miscellaneous private variables.
        !           218:  */
        !           219: char   udasr_bits[] = UDASR_BITS;
        !           220: 
        !           221: struct uba_device *udaip[NUDA][MAXUNIT];
        !           222:                                /* inverting pointers: ctlr & unit => Unibus
        !           223:                                   device pointer */
        !           224: 
        !           225: int    udaburst[NUDA] = { 0 }; /* burst size, per UDA50, zero => default;
        !           226:                                   in data space so patchable via adb */
        !           227: 
        !           228: struct mscp udaslavereply;     /* get unit status response packet, set
        !           229:                                   for udaslave by udaunconf, via udaintr */
        !           230: 
        !           231: static struct uba_ctlr *probeum;/* this is a hack---autoconf should pass ctlr
        !           232:                                   info to slave routine; instead, we remember
        !           233:                                   the last ctlr argument to probe */
        !           234: 
        !           235: int    udawstart, udawatch();  /* watchdog timer */
        !           236: 
        !           237: /*
        !           238:  * Externals
        !           239:  */
        !           240: int    wakeup();
        !           241: int    hz;
        !           242: 
        !           243: /*
        !           244:  * Poke at a supposed UDA50 to see if it is there.
        !           245:  * This routine duplicates some of the code in udainit() only
        !           246:  * because autoconf has not set up the right information yet.
        !           247:  * We have to do everything `by hand'.
        !           248:  */
        !           249: udaprobe(reg, ctlr, um)
        !           250:        caddr_t reg;
        !           251:        int ctlr;
        !           252:        struct uba_ctlr *um;
        !           253: {
        !           254:        register int br, cvec;
        !           255:        register struct uda_softc *sc;
        !           256:        register struct udadevice *udaddr;
        !           257:        register struct mscp_info *mi;
        !           258:        int timeout, tries;
        !           259: 
        !           260: #ifdef VAX750
        !           261:        /*
        !           262:         * The UDA50 wants to share BDPs on 750s, but not on 780s or
        !           263:         * 8600s.  (730s have no BDPs anyway.)  Toward this end, we
        !           264:         * here set the `keep bdp' flag in the per-driver information
        !           265:         * if this is a 750.  (We just need to do it once, but it is
        !           266:         * easiest to do it now, for each UDA50.)
        !           267:         */
        !           268:        if (cpu == VAX_750)
        !           269:                udadriver.ud_keepbdp = 1;
        !           270: #endif
        !           271: 
        !           272:        probeum = um;                   /* remember for udaslave() */
        !           273: #ifdef lint
        !           274:        br = 0; cvec = br; br = cvec; udaintr(0);
        !           275: #endif
        !           276:        /*
        !           277:         * Set up the controller-specific generic MSCP driver info.
        !           278:         * Note that this should really be done in the (nonexistent)
        !           279:         * controller attach routine.
        !           280:         */
        !           281:        sc = &uda_softc[ctlr];
        !           282:        mi = &sc->sc_mi;
        !           283:        mi->mi_md = &udamscpdriver;
        !           284:        mi->mi_ctlr = um->um_ctlr;
        !           285:        mi->mi_tab = &um->um_tab;
        !           286:        mi->mi_ip = udaip[ctlr];
        !           287:        mi->mi_cmd.mri_size = NCMD;
        !           288:        mi->mi_cmd.mri_desc = uda[ctlr].uda_ca.ca_cmddsc;
        !           289:        mi->mi_cmd.mri_ring = uda[ctlr].uda_cmd;
        !           290:        mi->mi_rsp.mri_size = NRSP;
        !           291:        mi->mi_rsp.mri_desc = uda[ctlr].uda_ca.ca_rspdsc;
        !           292:        mi->mi_rsp.mri_ring = uda[ctlr].uda_rsp;
        !           293:        mi->mi_wtab.av_forw = mi->mi_wtab.av_back = &mi->mi_wtab;
        !           294: 
        !           295:        /*
        !           296:         * More controller specific variables.  Again, this should
        !           297:         * be in the controller attach routine.
        !           298:         */
        !           299:        if (udaburst[ctlr] == 0)
        !           300:                udaburst[ctlr] = DEFAULT_BURST;
        !           301:                
        !           302:        /*
        !           303:         * Get an interrupt vector.  Note that even if the controller
        !           304:         * does not respond, we keep the vector.  This is not a serious
        !           305:         * problem; but it would be easily fixed if we had a controller
        !           306:         * attach routine.  Sigh.
        !           307:         */
        !           308:        sc->sc_ivec = (uba_hd[numuba].uh_lastiv -= 4);
        !           309:        udaddr = (struct udadevice *) reg;
        !           310: 
        !           311:        /*
        !           312:         * Initialise the controller (partially).  The UDA50 programmer's
        !           313:         * manual states that if initialisation fails, it should be retried
        !           314:         * at least once, but after a second failure the port should be
        !           315:         * considered `down'; it also mentions that the controller should
        !           316:         * initialise within ten seconds.  Or so I hear; I have not seen
        !           317:         * this manual myself.
        !           318:         */
        !           319:        tries = 0;
        !           320: again:
        !           321:        udaddr->udaip = 0;              /* start initialisation */
        !           322:        timeout = todr() + 1000;        /* timeout in 10 seconds */
        !           323:        while ((udaddr->udasa & UDA_STEP1) == 0)
        !           324:                if (todr() > timeout)
        !           325:                        goto bad;
        !           326:        udaddr->udasa = UDA_ERR | (NCMDL2 << 11) | (NRSPL2 << 8) | UDA_IE |
        !           327:                (sc->sc_ivec >> 2);
        !           328:        while ((udaddr->udasa & UDA_STEP2) == 0)
        !           329:                if (todr() > timeout)
        !           330:                        goto bad;
        !           331: 
        !           332:        /* should have interrupted by now */
        !           333: #ifdef VAX630
        !           334:        if (cpu == VAX_630)
        !           335:                br = 0x15;      /* screwy interrupt structure */
        !           336: #endif
        !           337:        return (sizeof (struct udadevice));
        !           338: bad:
        !           339:        if (++tries < 2)
        !           340:                goto again;
        !           341:        return (0);
        !           342: }
        !           343: 
        !           344: /*
        !           345:  * Find a slave.  We allow wildcard slave numbers (something autoconf
        !           346:  * is not really prepared to deal with); and we need to know the
        !           347:  * controller number to talk to the UDA.  For the latter, we keep
        !           348:  * track of the last controller probed, since a controller probe
        !           349:  * immediately precedes all slave probes for that controller.  For the
        !           350:  * former, we simply put the unit number into ui->ui_slave after we
        !           351:  * have found one.
        !           352:  *
        !           353:  * Note that by the time udaslave is called, the interrupt vector
        !           354:  * for the UDA50 has been set up (so that udaunconf() will be called).
        !           355:  */
        !           356: udaslave(ui, reg)
        !           357:        register struct uba_device *ui;
        !           358:        caddr_t reg;
        !           359: {
        !           360:        register struct uba_ctlr *um = probeum;
        !           361:        register struct mscp *mp;
        !           362:        register struct uda_softc *sc;
        !           363:        int next = 0, timeout, tries, i;
        !           364: 
        !           365: #ifdef lint
        !           366:        i = 0; i = i;
        !           367: #endif
        !           368:        /*
        !           369:         * Make sure the controller is fully initialised, by waiting
        !           370:         * for it if necessary.
        !           371:         */
        !           372:        sc = &uda_softc[um->um_ctlr];
        !           373:        if (sc->sc_state == ST_RUN)
        !           374:                goto findunit;
        !           375:        tries = 0;
        !           376: again:
        !           377:        if (udainit(ui->ui_ctlr))
        !           378:                return (0);
        !           379:        timeout = todr() + 1000;                /* 10 seconds */
        !           380:        while (todr() < timeout)
        !           381:                if (sc->sc_state == ST_RUN)     /* made it */
        !           382:                        goto findunit;
        !           383:        if (++tries < 2)
        !           384:                goto again;
        !           385:        printf("uda%d: controller hung\n", um->um_ctlr);
        !           386:        return (0);
        !           387: 
        !           388:        /*
        !           389:         * The controller is all set; go find the unit.  Grab an
        !           390:         * MSCP packet and send out a Get Unit Status command, with
        !           391:         * the `next unit' modifier if we are looking for a generic
        !           392:         * unit.  We set the `in slave' flag so that udaunconf()
        !           393:         * knows to copy the response to `udaslavereply'.
        !           394:         */
        !           395: findunit:
        !           396:        udaslavereply.mscp_opcode = 0;
        !           397:        sc->sc_flags |= SC_INSLAVE;
        !           398:        if ((mp = mscp_getcp(&sc->sc_mi, MSCP_DONTWAIT)) == NULL)
        !           399:                panic("udaslave");              /* `cannot happen' */
        !           400:        mp->mscp_opcode = M_OP_GETUNITST;
        !           401:        if (ui->ui_slave == '?') {
        !           402:                mp->mscp_unit = next;
        !           403:                mp->mscp_modifier = M_GUM_NEXTUNIT;
        !           404:        } else {
        !           405:                mp->mscp_unit = ui->ui_slave;
        !           406:                mp->mscp_modifier = 0;
        !           407:        }
        !           408:        *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
        !           409:        i = ((struct udadevice *) reg)->udaip;  /* initiate polling */
        !           410:        mp = &udaslavereply;
        !           411:        timeout = todr() + 1000;
        !           412:        while (todr() < timeout)
        !           413:                if (mp->mscp_opcode)
        !           414:                        goto gotit;
        !           415:        printf("uda%d: no response to Get Unit Status request\n",
        !           416:                um->um_ctlr);
        !           417:        sc->sc_flags &= ~SC_INSLAVE;
        !           418:        return (0);
        !           419: 
        !           420: gotit:
        !           421:        sc->sc_flags &= ~SC_INSLAVE;
        !           422: 
        !           423:        /*
        !           424:         * Got a slave response.  If the unit is there, use it.
        !           425:         */
        !           426:        switch (mp->mscp_status & M_ST_MASK) {
        !           427: 
        !           428:        case M_ST_SUCCESS:      /* worked */
        !           429:        case M_ST_AVAILABLE:    /* found another drive */
        !           430:                break;          /* use it */
        !           431: 
        !           432:        case M_ST_OFFLINE:
        !           433:                /*
        !           434:                 * Figure out why it is off line.  It may be because
        !           435:                 * it is nonexistent, or because it is spun down, or
        !           436:                 * for some other reason.
        !           437:                 */
        !           438:                switch (mp->mscp_status & ~M_ST_MASK) {
        !           439: 
        !           440:                case M_OFFLINE_UNKNOWN:
        !           441:                        /*
        !           442:                         * No such drive, and there are none with
        !           443:                         * higher unit numbers either, if we are
        !           444:                         * using M_GUM_NEXTUNIT.
        !           445:                         */
        !           446:                        return (0);
        !           447: 
        !           448:                case M_OFFLINE_UNMOUNTED:
        !           449:                        /*
        !           450:                         * The drive is not spun up.  Use it anyway.
        !           451:                         *
        !           452:                         * N.B.: this seems to be a common occurrance
        !           453:                         * after a power failure.  The first attempt
        !           454:                         * to bring it on line seems to spin it up
        !           455:                         * (and thus takes several minutes).  Perhaps
        !           456:                         * we should note here that the on-line may
        !           457:                         * take longer than usual.
        !           458:                         */
        !           459:                        break;
        !           460: 
        !           461:                default:
        !           462:                        /*
        !           463:                         * In service, or something else equally unusable.
        !           464:                         */
        !           465:                        printf("uda%d: unit %d off line: ", um->um_ctlr,
        !           466:                                mp->mscp_unit);
        !           467:                        mscp_printevent(mp);
        !           468:                        goto try_another;
        !           469:                }
        !           470:                break;
        !           471: 
        !           472:        default:
        !           473:                printf("uda%d: unable to get unit status: ", um->um_ctlr);
        !           474:                mscp_printevent(mp);
        !           475:                return (0);
        !           476:        }
        !           477: 
        !           478:        /*
        !           479:         * Does this ever happen?  What (if anything) does it mean?
        !           480:         */
        !           481:        if (mp->mscp_unit < next) {
        !           482:                printf("uda%d: unit %d, next %d\n",
        !           483:                        um->um_ctlr, mp->mscp_unit, next);
        !           484:                return (0);
        !           485:        }
        !           486: 
        !           487:        if (mp->mscp_unit >= MAXUNIT) {
        !           488:                printf("uda%d: cannot handle unit number %d (max is %d)\n",
        !           489:                        um->um_ctlr, mp->mscp_unit, MAXUNIT - 1);
        !           490:                return (0);
        !           491:        }
        !           492: 
        !           493:        /*
        !           494:         * See if we already handle this drive.
        !           495:         * (Only likely if ui->ui_slave=='?'.)
        !           496:         */
        !           497:        if (udaip[um->um_ctlr][mp->mscp_unit] != NULL) {
        !           498: try_another:
        !           499:                if (ui->ui_slave != '?')
        !           500:                        return (0);
        !           501:                next = mp->mscp_unit + 1;
        !           502:                goto findunit;
        !           503:        }
        !           504: 
        !           505:        /*
        !           506:         * Voila!
        !           507:         */
        !           508:        uda_rasave(ui->ui_unit, mp, 0);
        !           509:        ui->ui_flags = 0;       /* not on line, nor anything else */
        !           510:        ui->ui_slave = mp->mscp_unit;
        !           511:        return (1);
        !           512: }
        !           513: 
        !           514: /*
        !           515:  * Attach a found slave.  Make sure the watchdog timer is running.
        !           516:  * If this disk is being profiled, fill in the `mspw' value (used by
        !           517:  * what?).  Set up the inverting pointer, and attempt to bring the
        !           518:  * drive on line and read its label.
        !           519:  */
        !           520: udaattach(ui)
        !           521:        register struct uba_device *ui;
        !           522: {
        !           523:        register int unit = ui->ui_unit;
        !           524: 
        !           525:        if (udawstart == 0) {
        !           526:                timeout(udawatch, (caddr_t) 0, hz);
        !           527:                udawstart++;
        !           528:        }
        !           529: 
        !           530:        /*
        !           531:         * Floppies cannot be brought on line unless there is
        !           532:         * a disk in the drive.  Since an ONLINE while cold
        !           533:         * takes ten seconds to fail, and (when notyet becomes now)
        !           534:         * no sensible person will swap to one, we just
        !           535:         * defer the ONLINE until someone tries to use the drive.
        !           536:         *
        !           537:         * THIS ASSUMES THAT DRIVE TYPES ?X? ARE FLOPPIES
        !           538:         */
        !           539:        if (MSCP_MID_ECH(1, ra_info[unit].ra_mediaid) == 'X' - '@') {
        !           540:                printf(": floppy");
        !           541:                return;
        !           542:        }
        !           543:        if (ui->ui_dk >= 0)
        !           544:                dk_mspw[ui->ui_dk] = 1.0 / (60 * 31 * 256);     /* approx */
        !           545:        udaip[ui->ui_ctlr][ui->ui_slave] = ui;
        !           546: 
        !           547:        if (uda_rainit(ui, 0))
        !           548:                printf(": offline");
        !           549:        else {
        !           550:                printf(": %s, size = %d sectors",
        !           551:                    udalabel[unit].d_typename, ra_info[unit].ra_dsize);
        !           552: #ifdef notyet
        !           553:                addswap(makedev(UDADEVNUM, udaminor(unit, 0)), &udalabel[unit]);
        !           554: #endif
        !           555:        }
        !           556: }
        !           557: 
        !           558: /*
        !           559:  * Initialise a UDA50.  Return true iff something goes wrong.
        !           560:  */
        !           561: udainit(ctlr)
        !           562:        int ctlr;
        !           563: {
        !           564:        register struct uda_softc *sc;
        !           565:        register struct udadevice *udaddr;
        !           566:        struct uba_ctlr *um;
        !           567:        int timo, ubinfo;
        !           568: 
        !           569:        sc = &uda_softc[ctlr];
        !           570:        um = udaminfo[ctlr];
        !           571:        if ((sc->sc_flags & SC_MAPPED) == 0) {
        !           572:                /*
        !           573:                 * Map the communication area and command and
        !           574:                 * response packets into Unibus space.
        !           575:                 */
        !           576:                ubinfo = uballoc(um->um_ubanum, (caddr_t) &uda[ctlr],
        !           577:                        sizeof (struct uda), UBA_CANTWAIT);
        !           578:                if (ubinfo == 0) {
        !           579:                        printf("uda%d: uballoc map failed\n", ctlr);
        !           580:                        return (-1);
        !           581:                }
        !           582:                sc->sc_uda = (struct uda *) (ubinfo & 0x3ffff);
        !           583:                sc->sc_flags |= SC_MAPPED;
        !           584:        }
        !           585: 
        !           586:        /*
        !           587:         * While we are thinking about it, reset the next command
        !           588:         * and response indicies.
        !           589:         */
        !           590:        sc->sc_mi.mi_cmd.mri_next = 0;
        !           591:        sc->sc_mi.mi_rsp.mri_next = 0;
        !           592: 
        !           593:        /*
        !           594:         * Start up the hardware initialisation sequence.
        !           595:         */
        !           596: #define        STEP0MASK       (UDA_ERR | UDA_STEP4 | UDA_STEP3 | UDA_STEP2 | \
        !           597:                         UDA_STEP1 | UDA_NV)
        !           598: 
        !           599:        sc->sc_state = ST_IDLE; /* in case init fails */
        !           600:        udaddr = (struct udadevice *)um->um_addr;
        !           601:        udaddr->udaip = 0;
        !           602:        timo = todr() + 1000;
        !           603:        while ((udaddr->udasa & STEP0MASK) == 0) {
        !           604:                if (todr() > timo) {
        !           605:                        printf("uda%d: timeout during init\n", ctlr);
        !           606:                        return (-1);
        !           607:                }
        !           608:        }
        !           609:        if ((udaddr->udasa & STEP0MASK) != UDA_STEP1) {
        !           610:                printf("uda%d: init failed, sa=%b\n", ctlr,
        !           611:                        udaddr->udasa, udasr_bits);
        !           612:                udasaerror(um, 0);
        !           613:                return (-1);
        !           614:        }
        !           615: 
        !           616:        /*
        !           617:         * Success!  Record new state, and start step 1 initialisation.
        !           618:         * The rest is done in the interrupt handler.
        !           619:         */
        !           620:        sc->sc_state = ST_STEP1;
        !           621:        udaddr->udasa = UDA_ERR | (NCMDL2 << 11) | (NRSPL2 << 8) | UDA_IE |
        !           622:            (sc->sc_ivec >> 2);
        !           623:        return (0);
        !           624: }
        !           625: 
        !           626: /*
        !           627:  * Open a drive.
        !           628:  */
        !           629: /*ARGSUSED*/
        !           630: udaopen(dev, flag, fmt)
        !           631:        dev_t dev;
        !           632:        int flag, fmt;
        !           633: {
        !           634:        register int unit;
        !           635:        register struct uba_device *ui;
        !           636:        register struct uda_softc *sc;
        !           637:        register struct disklabel *lp;
        !           638:        register struct partition *pp;
        !           639:        register struct ra_info *ra;
        !           640:        int s, i, part, mask, error = 0;
        !           641:        daddr_t start, end;
        !           642: 
        !           643:        /*
        !           644:         * Make sure this is a reasonable open request.
        !           645:         */
        !           646:        unit = udaunit(dev);
        !           647:        if (unit >= NRA || (ui = udadinfo[unit]) == 0 || ui->ui_alive == 0)
        !           648:                return (ENXIO);
        !           649: 
        !           650:        /*
        !           651:         * Make sure the controller is running, by (re)initialising it if
        !           652:         * necessary.
        !           653:         */
        !           654:        sc = &uda_softc[ui->ui_ctlr];
        !           655:        s = spl5();
        !           656:        if (sc->sc_state != ST_RUN) {
        !           657:                if (sc->sc_state == ST_IDLE && udainit(ui->ui_ctlr)) {
        !           658:                        splx(s);
        !           659:                        return (EIO);
        !           660:                }
        !           661:                /*
        !           662:                 * In case it does not come up, make sure we will be
        !           663:                 * restarted in 10 seconds.  This corresponds to the
        !           664:                 * 10 second timeouts in udaprobe() and udaslave().
        !           665:                 */
        !           666:                sc->sc_flags |= SC_DOWAKE;
        !           667:                timeout(wakeup, (caddr_t) sc, 10 * hz);
        !           668:                sleep((caddr_t) sc, PRIBIO);
        !           669:                if (sc->sc_state != ST_RUN) {
        !           670:                        splx(s);
        !           671:                        printf("uda%d: controller hung\n", ui->ui_ctlr);
        !           672:                        return (EIO);
        !           673:                }
        !           674:                untimeout(wakeup, (caddr_t) sc);
        !           675:        }
        !           676: 
        !           677:        /*
        !           678:         * Wait for the state to settle
        !           679:         */
        !           680:        ra = &ra_info[unit];
        !           681:        while (ra->ra_state != OPEN && ra->ra_state != OPENRAW &&
        !           682:            ra->ra_state != CLOSED)
        !           683:                sleep((caddr_t)ra, PZERO + 1);
        !           684: 
        !           685:        /*
        !           686:         * If not on line, or we are not sure of the label, reinitialise
        !           687:         * the drive.
        !           688:         */
        !           689:        if ((ui->ui_flags & UNIT_ONLINE) == 0 ||
        !           690:            (ra->ra_state != OPEN && ra->ra_state != OPENRAW))
        !           691:                error = uda_rainit(ui, flag);
        !           692:        splx(s);
        !           693:        if (error)
        !           694:                return (error);
        !           695: 
        !           696:        part = udapart(dev);
        !           697:        lp = &udalabel[unit];
        !           698:        if (part >= lp->d_npartitions)
        !           699:                return (ENXIO);
        !           700:        /*
        !           701:         * Warn if a partition is opened that overlaps another
        !           702:         * already open, unless either is the `raw' partition
        !           703:         * (whole disk).
        !           704:         */
        !           705: #define        RAWPART         2       /* 'c' partition */     /* XXX */
        !           706:        mask = 1 << part;
        !           707:        if ((ra->ra_openpart & mask) == 0 && part != RAWPART) {
        !           708:                pp = &lp->d_partitions[part];
        !           709:                start = pp->p_offset;
        !           710:                end = pp->p_offset + pp->p_size;
        !           711:                for (pp = lp->d_partitions, i = 0;
        !           712:                     i < lp->d_npartitions; pp++, i++) {
        !           713:                        if (pp->p_offset + pp->p_size <= start ||
        !           714:                            pp->p_offset >= end || i == RAWPART)
        !           715:                                continue;
        !           716:                        if (ra->ra_openpart & (1 << i))
        !           717:                                log(LOG_WARNING,
        !           718:                                    "ra%d%c: overlaps open partition (%c)\n",
        !           719:                                    unit, part + 'a', i + 'a');
        !           720:                }
        !           721:        }
        !           722:        switch (fmt) {
        !           723:        case S_IFCHR:
        !           724:                ra->ra_copenpart |= mask;
        !           725:                break;
        !           726:        case S_IFBLK:
        !           727:                ra->ra_bopenpart |= mask;
        !           728:                break;
        !           729:        }
        !           730:        ra->ra_openpart |= mask;
        !           731:        return (0);
        !           732: }
        !           733: 
        !           734: /* ARGSUSED */
        !           735: udaclose(dev, flags, fmt)
        !           736:        dev_t dev;
        !           737:        int flags, fmt;
        !           738: {
        !           739:        register int unit = udaunit(dev);
        !           740:        register struct ra_info *ra = &ra_info[unit];
        !           741:        int s, mask = (1 << udapart(dev));
        !           742: 
        !           743:        switch (fmt) {
        !           744:        case S_IFCHR:
        !           745:                ra->ra_copenpart &= ~mask;
        !           746:                break;
        !           747:        case S_IFBLK:
        !           748:                ra->ra_bopenpart &= ~mask;
        !           749:                break;
        !           750:        }
        !           751:        ra->ra_openpart = ra->ra_copenpart | ra->ra_bopenpart;
        !           752: 
        !           753:        /*
        !           754:         * Should wait for I/O to complete on this partition even if
        !           755:         * others are open, but wait for work on blkflush().
        !           756:         */
        !           757:        if (ra->ra_openpart == 0) {
        !           758:                s = spl5();
        !           759:                while (udautab[unit].b_actf)
        !           760:                        sleep((caddr_t)&udautab[unit], PZERO - 1);
        !           761:                splx(s);
        !           762:                ra->ra_state = CLOSED;
        !           763:                ra->ra_wlabel = 0;
        !           764:        }
        !           765:        return (0);
        !           766: }
        !           767: 
        !           768: /*
        !           769:  * Initialise a drive.  If it is not already, bring it on line,
        !           770:  * and set a timeout on it in case it fails to respond.
        !           771:  * When on line, read in the pack label.
        !           772:  */
        !           773: uda_rainit(ui, flags)
        !           774:        register struct uba_device *ui;
        !           775:        int flags;
        !           776: {
        !           777:        register struct uda_softc *sc = &uda_softc[ui->ui_ctlr];
        !           778:        register struct disklabel *lp;
        !           779:        register struct mscp *mp;
        !           780:        register int unit = ui->ui_unit;
        !           781:        register struct ra_info *ra;
        !           782:        char *msg, *readdisklabel();
        !           783:        int s, i, udastrategy();
        !           784:        extern int cold;
        !           785: 
        !           786:        ra = &ra_info[unit];
        !           787:        if ((ui->ui_flags & UNIT_ONLINE) == 0) {
        !           788:                mp = mscp_getcp(&sc->sc_mi, MSCP_WAIT);
        !           789:                mp->mscp_opcode = M_OP_ONLINE;
        !           790:                mp->mscp_unit = ui->ui_slave;
        !           791:                mp->mscp_cmdref = (long)&ui->ui_flags;
        !           792:                *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
        !           793:                ra->ra_state = WANTOPEN;
        !           794:                if (!cold)
        !           795:                        s = spl5();
        !           796:                i = ((struct udadevice *)ui->ui_addr)->udaip;
        !           797: 
        !           798:                if (cold) {
        !           799:                        i = todr() + 1000;
        !           800:                        while ((ui->ui_flags & UNIT_ONLINE) == 0)
        !           801:                                if (todr() > i)
        !           802:                                        break;
        !           803:                } else {
        !           804:                        timeout(wakeup, (caddr_t)&ui->ui_flags, 10 * hz);
        !           805:                        sleep((caddr_t)&ui->ui_flags, PSWP + 1);
        !           806:                        splx(s);
        !           807:                        untimeout(wakeup, (caddr_t)&ui->ui_flags);
        !           808:                }
        !           809:                if (ra->ra_state != OPENRAW) {
        !           810:                        ra->ra_state = CLOSED;
        !           811:                        wakeup((caddr_t)ra);
        !           812:                        return (EIO);
        !           813:                }
        !           814:        }
        !           815: 
        !           816:        lp = &udalabel[unit];
        !           817:        lp->d_secsize = DEV_BSIZE;
        !           818:        lp->d_secperunit = ra->ra_dsize;
        !           819: 
        !           820:        if (flags & O_NDELAY)
        !           821:                return (0);
        !           822:        ra->ra_state = RDLABEL;
        !           823:        /*
        !           824:         * Set up default sizes until we have the label, or longer
        !           825:         * if there is none.  Set secpercyl, as readdisklabel wants
        !           826:         * to compute b_cylin (although we do not need it).
        !           827:         */
        !           828:        lp->d_secpercyl = 1;
        !           829:        lp->d_npartitions = 1;
        !           830:        lp->d_partitions[0].p_size = lp->d_secperunit;
        !           831:        lp->d_partitions[0].p_offset = 0;
        !           832: 
        !           833:        /*
        !           834:         * Read pack label.
        !           835:         */
        !           836:        if ((msg = readdisklabel(udaminor(unit, 0), udastrategy, lp)) != NULL) {
        !           837:                if (cold)
        !           838:                        printf(": %s", msg);
        !           839:                else
        !           840:                        log(LOG_ERR, "ra%d: %s\n", unit, msg);
        !           841: #ifdef COMPAT_42
        !           842:                if (udamaptype(unit, lp))
        !           843:                        ra->ra_state = OPEN;
        !           844:                else
        !           845:                        ra->ra_state = OPENRAW;
        !           846: #else
        !           847:                ra->ra_state = OPENRAW;
        !           848:                /* uda_makefakelabel(ra, lp); */
        !           849: #endif
        !           850:        } else
        !           851:                ra->ra_state = OPEN;
        !           852:        wakeup((caddr_t)ra);
        !           853:        return (0);
        !           854: }
        !           855: 
        !           856: /*
        !           857:  * Copy the geometry information for the given ra from a
        !           858:  * GET UNIT STATUS response.  If check, see if it changed.
        !           859:  */
        !           860: uda_rasave(unit, mp, check)
        !           861:        int unit;
        !           862:        register struct mscp *mp;
        !           863:        int check;
        !           864: {
        !           865:        register struct ra_info *ra = &ra_info[unit];
        !           866: 
        !           867:        if (check && ra->ra_mediaid != mp->mscp_guse.guse_mediaid) {
        !           868:                printf("ra%d: changed types! was %d now %d\n", unit,
        !           869:                        ra->ra_mediaid, mp->mscp_guse.guse_mediaid);
        !           870:                ra->ra_state = CLOSED;  /* ??? */
        !           871:        }
        !           872:        /* ra->ra_type = mp->mscp_guse.guse_drivetype; */
        !           873:        ra->ra_mediaid = mp->mscp_guse.guse_mediaid;
        !           874:        ra->ra_geom.rg_nsectors = mp->mscp_guse.guse_nspt;
        !           875:        ra->ra_geom.rg_ngroups = mp->mscp_guse.guse_group;
        !           876:        ra->ra_geom.rg_ngpc = mp->mscp_guse.guse_ngpc;
        !           877:        ra->ra_geom.rg_ntracks = ra->ra_geom.rg_ngroups * ra->ra_geom.rg_ngpc;
        !           878:        /* ra_geom.rg_ncyl cannot be computed until we have ra_dsize */
        !           879: #ifdef notyet
        !           880:        ra->ra_geom.rg_rctsize = mp->mscp_guse.guse_rctsize;
        !           881:        ra->ra_geom.rg_rbns = mp->mscp_guse.guse_nrpt;
        !           882:        ra->ra_geom.rg_nrct = mp->mscp_guse.guse_nrct;
        !           883: #endif
        !           884: }
        !           885: 
        !           886: /*
        !           887:  * Queue a transfer request, and if possible, hand it to the controller.
        !           888:  *
        !           889:  * This routine is broken into two so that the internal version
        !           890:  * udastrat1() can be called by the (nonexistent, as yet) bad block
        !           891:  * revectoring routine.
        !           892:  */
        !           893: udastrategy(bp)
        !           894:        register struct buf *bp;
        !           895: {
        !           896:        register int unit;
        !           897:        register struct uba_device *ui;
        !           898:        register struct ra_info *ra;
        !           899:        struct partition *pp;
        !           900:        int p;
        !           901:        daddr_t sz, maxsz;
        !           902: 
        !           903:        /*
        !           904:         * Make sure this is a reasonable drive to use.
        !           905:         */
        !           906:        if ((unit = udaunit(bp->b_dev)) >= NRA ||
        !           907:            (ui = udadinfo[unit]) == NULL || ui->ui_alive == 0 ||
        !           908:            (ra = &ra_info[unit])->ra_state == CLOSED) {
        !           909:                bp->b_error = ENXIO;
        !           910:                goto bad;
        !           911:        }
        !           912: 
        !           913:        /*
        !           914:         * If drive is open `raw' or reading label, let it at it.
        !           915:         */
        !           916:        if (ra->ra_state < OPEN) {
        !           917:                udastrat1(bp);
        !           918:                return;
        !           919:        }
        !           920:        p = udapart(bp->b_dev);
        !           921:        if ((ra->ra_openpart & (1 << p)) == 0) {
        !           922:                bp->b_error = ENODEV;
        !           923:                goto bad;
        !           924:        }
        !           925: 
        !           926:        /*
        !           927:         * Determine the size of the transfer, and make sure it is
        !           928:         * within the boundaries of the partition.
        !           929:         */
        !           930:        pp = &udalabel[unit].d_partitions[p];
        !           931:        maxsz = pp->p_size;
        !           932:        if (pp->p_offset + pp->p_size > ra->ra_dsize)
        !           933:                maxsz = ra->ra_dsize - pp->p_offset;
        !           934:        sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT;
        !           935:        if (bp->b_blkno + pp->p_offset <= LABELSECTOR &&
        !           936: #if LABELSECTOR != 0
        !           937:            bp->b_blkno + pp->p_offset + sz > LABELSECTOR &&
        !           938: #endif
        !           939:            (bp->b_flags & B_READ) == 0 && ra->ra_wlabel == 0) {
        !           940:                bp->b_error = EROFS;
        !           941:                goto bad;
        !           942:        }
        !           943:        if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz) {
        !           944:                /* if exactly at end of disk, return an EOF */
        !           945:                if (bp->b_blkno == maxsz) {
        !           946:                        bp->b_resid = bp->b_bcount;
        !           947:                        biodone(bp);
        !           948:                        return;
        !           949:                }
        !           950:                /* or truncate if part of it fits */
        !           951:                sz = maxsz - bp->b_blkno;
        !           952:                if (sz <= 0) {
        !           953:                        bp->b_error = EINVAL;   /* or hang it up */
        !           954:                        goto bad;
        !           955:                }
        !           956:                bp->b_bcount = sz << DEV_BSHIFT;
        !           957:        }
        !           958:        udastrat1(bp);
        !           959:        return;
        !           960: bad:
        !           961:        bp->b_flags |= B_ERROR;
        !           962:        biodone(bp);
        !           963: }
        !           964: 
        !           965: /*
        !           966:  * Work routine for udastrategy.
        !           967:  */
        !           968: udastrat1(bp)
        !           969:        register struct buf *bp;
        !           970: {
        !           971:        register int unit = udaunit(bp->b_dev);
        !           972:        register struct uba_ctlr *um;
        !           973:        register struct buf *dp;
        !           974:        struct uba_device *ui;
        !           975:        int s = spl5();
        !           976: 
        !           977:        /*
        !           978:         * Append the buffer to the drive queue, and if it is not
        !           979:         * already there, the drive to the controller queue.  (However,
        !           980:         * if the drive queue is marked to be requeued, we must be
        !           981:         * awaiting an on line or get unit status command; in this
        !           982:         * case, leave it off the controller queue.)
        !           983:         */
        !           984:        um = (ui = udadinfo[unit])->ui_mi;
        !           985:        dp = &udautab[unit];
        !           986:        APPEND(bp, dp, av_forw);
        !           987:        if (dp->b_active == 0 && (ui->ui_flags & UNIT_REQUEUE) == 0) {
        !           988:                APPEND(dp, &um->um_tab, b_forw);
        !           989:                dp->b_active++;
        !           990:        }
        !           991: 
        !           992:        /*
        !           993:         * Start activity on the controller.  Note that unlike other
        !           994:         * Unibus drivers, we must always do this, not just when the
        !           995:         * controller is not active.
        !           996:         */
        !           997:        udastart(um);
        !           998:        splx(s);
        !           999: }
        !          1000: 
        !          1001: /*
        !          1002:  * Start up whatever transfers we can find.
        !          1003:  * Note that udastart() must be called at spl5().
        !          1004:  */
        !          1005: udastart(um)
        !          1006:        register struct uba_ctlr *um;
        !          1007: {
        !          1008:        register struct uda_softc *sc = &uda_softc[um->um_ctlr];
        !          1009:        register struct buf *bp, *dp;
        !          1010:        register struct mscp *mp;
        !          1011:        struct uba_device *ui;
        !          1012:        struct udadevice *udaddr;
        !          1013:        struct partition *pp;
        !          1014:        int i, sz;
        !          1015: 
        !          1016: #ifdef lint
        !          1017:        i = 0; i = i;
        !          1018: #endif
        !          1019:        /*
        !          1020:         * If it is not running, try (again and again...) to initialise
        !          1021:         * it.  If it is currently initialising just ignore it for now.
        !          1022:         */
        !          1023:        if (sc->sc_state != ST_RUN) {
        !          1024:                if (sc->sc_state == ST_IDLE && udainit(um->um_ctlr))
        !          1025:                        printf("uda%d: still hung\n", um->um_ctlr);
        !          1026:                return;
        !          1027:        }
        !          1028: 
        !          1029:        /*
        !          1030:         * If um_cmd is nonzero, this controller is on the Unibus
        !          1031:         * resource wait queue.  It will not help to try more requests;
        !          1032:         * instead, when the Unibus unblocks and calls udadgo(), we
        !          1033:         * will call udastart() again.
        !          1034:         */
        !          1035:        if (um->um_cmd)
        !          1036:                return;
        !          1037: 
        !          1038:        sc->sc_flags |= SC_INSTART;
        !          1039:        udaddr = (struct udadevice *) um->um_addr;
        !          1040: 
        !          1041: loop:
        !          1042:        /*
        !          1043:         * Service the drive at the head of the queue.  It may not
        !          1044:         * need anything, in which case it might be shutting down
        !          1045:         * in udaclose().
        !          1046:         */
        !          1047:        if ((dp = um->um_tab.b_actf) == NULL)
        !          1048:                goto out;
        !          1049:        if ((bp = dp->b_actf) == NULL) {
        !          1050:                dp->b_active = 0;
        !          1051:                um->um_tab.b_actf = dp->b_forw;
        !          1052:                if (ra_info[dp - udautab].ra_openpart == 0)
        !          1053:                        wakeup((caddr_t)dp); /* finish close protocol */
        !          1054:                goto loop;
        !          1055:        }
        !          1056: 
        !          1057:        if (udaddr->udasa & UDA_ERR) {  /* ctlr fatal error */
        !          1058:                udasaerror(um, 1);
        !          1059:                goto out;
        !          1060:        }
        !          1061: 
        !          1062:        /*
        !          1063:         * Get an MSCP packet, then figure out what to do.  If
        !          1064:         * we cannot get a command packet, the command ring may
        !          1065:         * be too small:  We should have at least as many command
        !          1066:         * packets as credits, for best performance.
        !          1067:         */
        !          1068:        if ((mp = mscp_getcp(&sc->sc_mi, MSCP_DONTWAIT)) == NULL) {
        !          1069:                if (sc->sc_mi.mi_credits > MSCP_MINCREDITS &&
        !          1070:                    (sc->sc_flags & SC_GRIPED) == 0) {
        !          1071:                        log(LOG_NOTICE, "uda%d: command ring too small\n",
        !          1072:                                um->um_ctlr);
        !          1073:                        sc->sc_flags |= SC_GRIPED;/* complain only once */
        !          1074:                }
        !          1075:                goto out;
        !          1076:        }
        !          1077: 
        !          1078:        /*
        !          1079:         * Bring the drive on line if it is not already.  Get its status
        !          1080:         * if we do not already have it.  Otherwise just start the transfer.
        !          1081:         */
        !          1082:        ui = udadinfo[udaunit(bp->b_dev)];
        !          1083:        if ((ui->ui_flags & UNIT_ONLINE) == 0) {
        !          1084:                mp->mscp_opcode = M_OP_ONLINE;
        !          1085:                goto common;
        !          1086:        }
        !          1087:        if ((ui->ui_flags & UNIT_HAVESTATUS) == 0) {
        !          1088:                mp->mscp_opcode = M_OP_GETUNITST;
        !          1089: common:
        !          1090: if (ui->ui_flags & UNIT_REQUEUE) panic("udastart");
        !          1091:                /*
        !          1092:                 * Take the drive off the controller queue.  When the
        !          1093:                 * command finishes, make sure the drive is requeued.
        !          1094:                 */
        !          1095:                um->um_tab.b_actf = dp->b_forw;
        !          1096:                dp->b_active = 0;
        !          1097:                ui->ui_flags |= UNIT_REQUEUE;
        !          1098:                mp->mscp_unit = ui->ui_slave;
        !          1099:                *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
        !          1100:                sc->sc_flags |= SC_STARTPOLL;
        !          1101: #ifdef POLLSTATS
        !          1102:                sc->sc_ncmd++;
        !          1103: #endif
        !          1104:                goto loop;
        !          1105:        }
        !          1106: 
        !          1107:        pp = &udalabel[ui->ui_unit].d_partitions[udapart(bp->b_dev)];
        !          1108:        mp->mscp_opcode = (bp->b_flags & B_READ) ? M_OP_READ : M_OP_WRITE;
        !          1109:        mp->mscp_unit = ui->ui_slave;
        !          1110:        mp->mscp_seq.seq_lbn = bp->b_blkno + pp->p_offset;
        !          1111:        sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT;
        !          1112:        mp->mscp_seq.seq_bytecount = bp->b_blkno + sz > pp->p_size ?
        !          1113:                (pp->p_size - bp->b_blkno) >> DEV_BSHIFT : bp->b_bcount;
        !          1114:        /* mscp_cmdref is filled in by mscp_go() */
        !          1115: 
        !          1116:        /*
        !          1117:         * Drop the packet pointer into the `command' field so udadgo()
        !          1118:         * can tell what to start.  If ubago returns 1, we can do another
        !          1119:         * transfer.  If not, um_cmd will still point at mp, so we will
        !          1120:         * know that we are waiting for resources.
        !          1121:         */
        !          1122:        um->um_cmd = (int)mp;
        !          1123:        if (ubago(ui))
        !          1124:                goto loop;
        !          1125: 
        !          1126:        /*
        !          1127:         * All done, or blocked in ubago().  If we managed to
        !          1128:         * issue some commands, start up the beast.
        !          1129:         */
        !          1130: out:
        !          1131:        if (sc->sc_flags & SC_STARTPOLL) {
        !          1132: #ifdef POLLSTATS
        !          1133:                udastats.cmd[sc->sc_ncmd]++;
        !          1134:                sc->sc_ncmd = 0;
        !          1135: #endif
        !          1136:                i = ((struct udadevice *)um->um_addr)->udaip;
        !          1137:        }
        !          1138:        sc->sc_flags &= ~(SC_INSTART | SC_STARTPOLL);
        !          1139: }
        !          1140: 
        !          1141: /*
        !          1142:  * Start a transfer.
        !          1143:  *
        !          1144:  * If we are not called from within udastart(), we must have been
        !          1145:  * blocked, so call udastart to do more requests (if any).  If
        !          1146:  * this calls us again immediately we will not recurse, because
        !          1147:  * that time we will be in udastart().  Clever....
        !          1148:  */
        !          1149: udadgo(um)
        !          1150:        register struct uba_ctlr *um;
        !          1151: {
        !          1152:        struct uda_softc *sc = &uda_softc[um->um_ctlr];
        !          1153:        struct mscp *mp = (struct mscp *)um->um_cmd;
        !          1154: 
        !          1155:        um->um_tab.b_active++;  /* another transfer going */
        !          1156: 
        !          1157:        /*
        !          1158:         * Fill in the MSCP packet and move the buffer to the
        !          1159:         * I/O wait queue.  Mark the controller as no longer on
        !          1160:         * the resource queue, and remember to initiate polling.
        !          1161:         */
        !          1162:        mp->mscp_seq.seq_buffer = (um->um_ubinfo & 0x3ffff) |
        !          1163:                (UBAI_BDP(um->um_ubinfo) << 24);
        !          1164:        mscp_go(&sc->sc_mi, mp, um->um_ubinfo);
        !          1165:        um->um_cmd = 0; 
        !          1166:        um->um_ubinfo = 0;      /* tyke it awye */
        !          1167:        sc->sc_flags |= SC_STARTPOLL;
        !          1168: #ifdef POLLSTATS
        !          1169:        sc->sc_ncmd++;
        !          1170: #endif
        !          1171:        if ((sc->sc_flags & SC_INSTART) == 0)
        !          1172:                udastart(um);
        !          1173: }
        !          1174: 
        !          1175: udaiodone(mi, bp, info)
        !          1176:        register struct mscp_info *mi;
        !          1177:        struct buf *bp;
        !          1178:        int info;
        !          1179: {
        !          1180:        register struct uba_ctlr *um = udaminfo[mi->mi_ctlr];
        !          1181: 
        !          1182:        um->um_ubinfo = info;
        !          1183:        ubadone(um);
        !          1184:        biodone(bp);
        !          1185:        if (um->um_bdp && mi->mi_wtab.av_forw == &mi->mi_wtab)
        !          1186:                ubarelse(um->um_ubanum, &um->um_bdp);
        !          1187:        um->um_tab.b_active--;  /* another transfer done */
        !          1188: }
        !          1189: 
        !          1190: static struct saerr {
        !          1191:        int     code;           /* error code (including UDA_ERR) */
        !          1192:        char    *desc;          /* what it means: Efoo => foo error */
        !          1193: } saerr[] = {
        !          1194:        { 0100001, "Eunibus packet read" },
        !          1195:        { 0100002, "Eunibus packet write" },
        !          1196:        { 0100003, "EUDA ROM and RAM parity" },
        !          1197:        { 0100004, "EUDA RAM parity" },
        !          1198:        { 0100005, "EUDA ROM parity" },
        !          1199:        { 0100006, "Eunibus ring read" },
        !          1200:        { 0100007, "Eunibus ring write" },
        !          1201:        { 0100010, " unibus interrupt master failure" },
        !          1202:        { 0100011, "Ehost access timeout" },
        !          1203:        { 0100012, " host exceeded command limit" },
        !          1204:        { 0100013, " unibus bus master failure" },
        !          1205:        { 0100014, " DM XFC fatal error" },
        !          1206:        { 0100015, " hardware timeout of instruction loop" },
        !          1207:        { 0100016, " invalid virtual circuit id" },
        !          1208:        { 0100017, "Eunibus interrupt write" },
        !          1209:        { 0104000, "Efatal sequence" },
        !          1210:        { 0104040, " D proc ALU" },
        !          1211:        { 0104041, "ED proc control ROM parity" },
        !          1212:        { 0105102, "ED proc w/no BD#2 or RAM parity" },
        !          1213:        { 0105105, "ED proc RAM buffer" },
        !          1214:        { 0105152, "ED proc SDI" },
        !          1215:        { 0105153, "ED proc write mode wrap serdes" },
        !          1216:        { 0105154, "ED proc read mode serdes, RSGEN & ECC" },
        !          1217:        { 0106040, "EU proc ALU" },
        !          1218:        { 0106041, "EU proc control reg" },
        !          1219:        { 0106042, " U proc DFAIL/cntl ROM parity/BD #1 test CNT" },
        !          1220:        { 0106047, " U proc const PROM err w/D proc running SDI test" },
        !          1221:        { 0106055, " unexpected trap" },
        !          1222:        { 0106071, "EU proc const PROM" },
        !          1223:        { 0106072, "EU proc control ROM parity" },
        !          1224:        { 0106200, "Estep 1 data" },
        !          1225:        { 0107103, "EU proc RAM parity" },
        !          1226:        { 0107107, "EU proc RAM buffer" },
        !          1227:        { 0107115, " test count wrong (BD 12)" },
        !          1228:        { 0112300, "Estep 2" },
        !          1229:        { 0122240, "ENPR" },
        !          1230:        { 0122300, "Estep 3" },
        !          1231:        { 0142300, "Estep 4" },
        !          1232:        { 0, " unknown error code" }
        !          1233: };
        !          1234: 
        !          1235: /*
        !          1236:  * If the error bit was set in the controller status register, gripe,
        !          1237:  * then (optionally) reset the controller and requeue pending transfers.
        !          1238:  */
        !          1239: udasaerror(um, doreset)
        !          1240:        register struct uba_ctlr *um;
        !          1241:        int doreset;
        !          1242: {
        !          1243:        register int code = ((struct udadevice *)um->um_addr)->udasa;
        !          1244:        register struct saerr *e;
        !          1245: 
        !          1246:        if ((code & UDA_ERR) == 0)
        !          1247:                return;
        !          1248:        for (e = saerr; e->code; e++)
        !          1249:                if (e->code == code)
        !          1250:                        break;
        !          1251:        printf("uda%d: controller error, sa=0%o (%s%s)\n",
        !          1252:                um->um_ctlr, code, e->desc + 1,
        !          1253:                *e->desc == 'E' ? " error" : "");
        !          1254:        if (doreset) {
        !          1255:                mscp_requeue(&uda_softc[um->um_ctlr].sc_mi);
        !          1256:                (void) udainit(um->um_ctlr);
        !          1257:        }
        !          1258: }
        !          1259: 
        !          1260: /*
        !          1261:  * Interrupt routine.  Depending on the state of the controller,
        !          1262:  * continue initialisation, or acknowledge command and response
        !          1263:  * interrupts, and process responses.
        !          1264:  */
        !          1265: udaintr(ctlr)
        !          1266:        int ctlr;
        !          1267: {
        !          1268:        register struct uba_ctlr *um = udaminfo[ctlr];
        !          1269:        register struct uda_softc *sc = &uda_softc[ctlr];
        !          1270:        register struct udadevice *udaddr = (struct udadevice *)um->um_addr;
        !          1271:        register struct uda *ud;
        !          1272:        register struct mscp *mp;
        !          1273:        register int i;
        !          1274: 
        !          1275: #ifdef VAX630
        !          1276:        (void) spl5();          /* Qbus interrupt protocol is odd */
        !          1277: #endif
        !          1278:        sc->sc_wticks = 0;      /* reset interrupt watchdog */
        !          1279: 
        !          1280:        /*
        !          1281:         * Combinations during steps 1, 2, and 3: STEPnMASK
        !          1282:         * corresponds to which bits should be tested;
        !          1283:         * STEPnGOOD corresponds to the pattern that should
        !          1284:         * appear after the interrupt from STEPn initialisation.
        !          1285:         * All steps test the bits in ALLSTEPS.
        !          1286:         */
        !          1287: #define        ALLSTEPS        (UDA_ERR|UDA_STEP4|UDA_STEP3|UDA_STEP2|UDA_STEP1)
        !          1288: 
        !          1289: #define        STEP1MASK       (ALLSTEPS | UDA_IE | UDA_NCNRMASK)
        !          1290: #define        STEP1GOOD       (UDA_STEP2 | UDA_IE | (NCMDL2 << 3) | NRSPL2)
        !          1291: 
        !          1292: #define        STEP2MASK       (ALLSTEPS | UDA_IE | UDA_IVECMASK)
        !          1293: #define        STEP2GOOD       (UDA_STEP3 | UDA_IE | (sc->sc_ivec >> 2))
        !          1294: 
        !          1295: #define        STEP3MASK       ALLSTEPS
        !          1296: #define        STEP3GOOD       UDA_STEP4
        !          1297: 
        !          1298:        switch (sc->sc_state) {
        !          1299: 
        !          1300:        case ST_IDLE:
        !          1301:                /*
        !          1302:                 * Ignore unsolicited interrupts.
        !          1303:                 */
        !          1304:                log(LOG_WARNING, "uda%d: stray intr\n", ctlr);
        !          1305:                return;
        !          1306: 
        !          1307:        case ST_STEP1:
        !          1308:                /*
        !          1309:                 * Begin step two initialisation.
        !          1310:                 */
        !          1311:                if ((udaddr->udasa & STEP1MASK) != STEP1GOOD) {
        !          1312:                        i = 1;
        !          1313: initfailed:
        !          1314:                        printf("uda%d: init step %d failed, sa=%b\n",
        !          1315:                                ctlr, i, udaddr->udasa, udasr_bits);
        !          1316:                        udasaerror(um, 0);
        !          1317:                        sc->sc_state = ST_IDLE;
        !          1318:                        if (sc->sc_flags & SC_DOWAKE) {
        !          1319:                                sc->sc_flags &= ~SC_DOWAKE;
        !          1320:                                wakeup((caddr_t)sc);
        !          1321:                        }
        !          1322:                        return;
        !          1323:                }
        !          1324:                udaddr->udasa = (int)&sc->sc_uda->uda_ca.ca_rspdsc[0] |
        !          1325:                        (cpu == VAX_780 || cpu == VAX_8600 ? UDA_PI : 0);
        !          1326:                sc->sc_state = ST_STEP2;
        !          1327:                return;
        !          1328: 
        !          1329:        case ST_STEP2:
        !          1330:                /*
        !          1331:                 * Begin step 3 initialisation.
        !          1332:                 */
        !          1333:                if ((udaddr->udasa & STEP2MASK) != STEP2GOOD) {
        !          1334:                        i = 2;
        !          1335:                        goto initfailed;
        !          1336:                }
        !          1337:                udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_rspdsc[0]) >> 16;
        !          1338:                sc->sc_state = ST_STEP3;
        !          1339:                return;
        !          1340: 
        !          1341:        case ST_STEP3:
        !          1342:                /*
        !          1343:                 * Set controller characteristics (finish initialisation).
        !          1344:                 */
        !          1345:                if ((udaddr->udasa & STEP3MASK) != STEP3GOOD) {
        !          1346:                        i = 3;
        !          1347:                        goto initfailed;
        !          1348:                }
        !          1349:                i = udaddr->udasa & 0xff;
        !          1350:                if (i != sc->sc_micro) {
        !          1351:                        sc->sc_micro = i;
        !          1352:                        printf("uda%d: version %d model %d\n",
        !          1353:                                ctlr, i & 0xf, i >> 4);
        !          1354:                }
        !          1355: 
        !          1356:                /*
        !          1357:                 * Present the burst size, then remove it.  Why this
        !          1358:                 * should be done this way, I have no idea.
        !          1359:                 *
        !          1360:                 * Note that this assumes udaburst[ctlr] > 0.
        !          1361:                 */
        !          1362:                udaddr->udasa = UDA_GO | (udaburst[ctlr] - 1) << 2;
        !          1363:                udaddr->udasa = UDA_GO;
        !          1364:                printf("uda%d: DMA burst size set to %d\n",
        !          1365:                        ctlr, udaburst[ctlr]);
        !          1366: 
        !          1367:                udainitds(ctlr);        /* initialise data structures */
        !          1368: 
        !          1369:                /*
        !          1370:                 * Before we can get a command packet, we need some
        !          1371:                 * credits.  Fake some up to keep mscp_getcp() happy,
        !          1372:                 * get a packet, and cancel all credits (the right
        !          1373:                 * number should come back in the response to the
        !          1374:                 * SCC packet).
        !          1375:                 */
        !          1376:                sc->sc_mi.mi_credits = MSCP_MINCREDITS + 1;
        !          1377:                mp = mscp_getcp(&sc->sc_mi, MSCP_DONTWAIT);
        !          1378:                if (mp == NULL) /* `cannot happen' */
        !          1379:                        panic("udaintr");
        !          1380:                sc->sc_mi.mi_credits = 0;
        !          1381:                mp->mscp_opcode = M_OP_SETCTLRC;
        !          1382:                mp->mscp_unit = 0;
        !          1383:                mp->mscp_sccc.sccc_ctlrflags = M_CF_ATTN | M_CF_MISC |
        !          1384:                        M_CF_THIS;
        !          1385:                *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
        !          1386:                i = udaddr->udaip;
        !          1387:                sc->sc_state = ST_SETCHAR;
        !          1388:                return;
        !          1389: 
        !          1390:        case ST_SETCHAR:
        !          1391:        case ST_RUN:
        !          1392:                /*
        !          1393:                 * Handle Set Ctlr Characteristics responses and operational
        !          1394:                 * responses (via mscp_dorsp).
        !          1395:                 */
        !          1396:                break;
        !          1397: 
        !          1398:        default:
        !          1399:                printf("uda%d: driver bug, state %d\n", ctlr, sc->sc_state);
        !          1400:                panic("udastate");
        !          1401:        }
        !          1402: 
        !          1403:        if (udaddr->udasa & UDA_ERR) {  /* ctlr fatal error */
        !          1404:                udasaerror(um, 1);
        !          1405:                return;
        !          1406:        }
        !          1407: 
        !          1408:        ud = &uda[ctlr];
        !          1409: 
        !          1410:        /*
        !          1411:         * Handle buffer purge requests.
        !          1412:         */
        !          1413:        if (ud->uda_ca.ca_bdp) {
        !          1414:                UBAPURGE(um->um_hd->uh_uba, ud->uda_ca.ca_bdp);
        !          1415:                ud->uda_ca.ca_bdp = 0;
        !          1416:                udaddr->udasa = 0;      /* signal purge complete */
        !          1417:        }
        !          1418: 
        !          1419:        /*
        !          1420:         * Check for response and command ring transitions.
        !          1421:         */
        !          1422:        if (ud->uda_ca.ca_rspint) {
        !          1423:                ud->uda_ca.ca_rspint = 0;
        !          1424:                mscp_dorsp(&sc->sc_mi);
        !          1425:        }
        !          1426:        if (ud->uda_ca.ca_cmdint) {
        !          1427:                ud->uda_ca.ca_cmdint = 0;
        !          1428:                MSCP_DOCMD(&sc->sc_mi);
        !          1429:        }
        !          1430:        udastart(um);
        !          1431: }
        !          1432: 
        !          1433: /*
        !          1434:  * Initialise the various data structures that control the UDA50.
        !          1435:  */
        !          1436: udainitds(ctlr)
        !          1437:        int ctlr;
        !          1438: {
        !          1439:        register struct uda *ud = &uda[ctlr];
        !          1440:        register struct uda *uud = uda_softc[ctlr].sc_uda;
        !          1441:        register struct mscp *mp;
        !          1442:        register int i;
        !          1443: 
        !          1444:        for (i = 0, mp = ud->uda_rsp; i < NRSP; i++, mp++) {
        !          1445:                ud->uda_ca.ca_rspdsc[i] = MSCP_OWN | MSCP_INT |
        !          1446:                        (long)&uud->uda_rsp[i].mscp_cmdref;
        !          1447:                mp->mscp_addr = &ud->uda_ca.ca_rspdsc[i];
        !          1448:                mp->mscp_msglen = MSCP_MSGLEN;
        !          1449:        }
        !          1450:        for (i = 0, mp = ud->uda_cmd; i < NCMD; i++, mp++) {
        !          1451:                ud->uda_ca.ca_cmddsc[i] = MSCP_INT |
        !          1452:                        (long)&uud->uda_cmd[i].mscp_cmdref;
        !          1453:                mp->mscp_addr = &ud->uda_ca.ca_cmddsc[i];
        !          1454:                mp->mscp_msglen = MSCP_MSGLEN;
        !          1455:        }
        !          1456: }
        !          1457: 
        !          1458: /*
        !          1459:  * Handle an error datagram.
        !          1460:  */
        !          1461: udadgram(mi, mp)
        !          1462:        struct mscp_info *mi;
        !          1463:        struct mscp *mp;
        !          1464: {
        !          1465: 
        !          1466:        mscp_decodeerror(mi->mi_md->md_mname, mi->mi_ctlr, mp);
        !          1467:        /*
        !          1468:         * SDI status information bytes 10 and 11 are the microprocessor
        !          1469:         * error code and front panel code respectively.  These vary per
        !          1470:         * drive type and are printed purely for field service information.
        !          1471:         */
        !          1472:        if (mp->mscp_format == M_FM_SDI)
        !          1473:                printf("\tsdi uproc error code 0x%x, front panel code 0x%x\n",
        !          1474:                        mp->mscp_erd.erd_sdistat[10],
        !          1475:                        mp->mscp_erd.erd_sdistat[11]);
        !          1476: }
        !          1477: 
        !          1478: /*
        !          1479:  * The Set Controller Characteristics command finished.
        !          1480:  * Record the new state of the controller.
        !          1481:  */
        !          1482: udactlrdone(mi, mp)
        !          1483:        register struct mscp_info *mi;
        !          1484:        struct mscp *mp;
        !          1485: {
        !          1486:        register struct uda_softc *sc = &uda_softc[mi->mi_ctlr];
        !          1487: 
        !          1488:        if ((mp->mscp_status & M_ST_MASK) == M_ST_SUCCESS)
        !          1489:                sc->sc_state = ST_RUN;
        !          1490:        else {
        !          1491:                printf("uda%d: SETCTLRC failed: ",
        !          1492:                        mi->mi_ctlr, mp->mscp_status);
        !          1493:                mscp_printevent(mp);
        !          1494:                sc->sc_state = ST_IDLE;
        !          1495:        }
        !          1496:        if (sc->sc_flags & SC_DOWAKE) {
        !          1497:                sc->sc_flags &= ~SC_DOWAKE;
        !          1498:                wakeup((caddr_t)sc);
        !          1499:        }
        !          1500: }
        !          1501: 
        !          1502: /*
        !          1503:  * Received a response from an as-yet unconfigured drive.  Configure it
        !          1504:  * in, if possible.
        !          1505:  */
        !          1506: udaunconf(mi, mp)
        !          1507:        struct mscp_info *mi;
        !          1508:        register struct mscp *mp;
        !          1509: {
        !          1510: 
        !          1511:        /*
        !          1512:         * If it is a slave response, copy it to udaslavereply for
        !          1513:         * udaslave() to look at.
        !          1514:         */
        !          1515:        if (mp->mscp_opcode == (M_OP_GETUNITST | M_OP_END) &&
        !          1516:            (uda_softc[mi->mi_ctlr].sc_flags & SC_INSLAVE) != 0) {
        !          1517:                udaslavereply = *mp;
        !          1518:                return (MSCP_DONE);
        !          1519:        }
        !          1520: 
        !          1521:        /*
        !          1522:         * Otherwise, it had better be an available attention response.
        !          1523:         */
        !          1524:        if (mp->mscp_opcode != M_OP_AVAILATTN)
        !          1525:                return (MSCP_FAILED);
        !          1526: 
        !          1527:        /* do what autoconf does */
        !          1528:        return (MSCP_FAILED);   /* not yet, arwhite, not yet */
        !          1529: }
        !          1530: 
        !          1531: /*
        !          1532:  * A drive came on line.  Check its type and size.  Return DONE if
        !          1533:  * we think the drive is truly on line.  In any case, awaken anyone
        !          1534:  * sleeping on the drive on-line-ness.
        !          1535:  */
        !          1536: udaonline(ui, mp)
        !          1537:        register struct uba_device *ui;
        !          1538:        struct mscp *mp;
        !          1539: {
        !          1540:        register struct ra_info *ra = &ra_info[ui->ui_unit];
        !          1541: 
        !          1542:        wakeup((caddr_t)&ui->ui_flags);
        !          1543:        if ((mp->mscp_status & M_ST_MASK) != M_ST_SUCCESS) {
        !          1544:                printf("uda%d: attempt to bring ra%d on line failed: ",
        !          1545:                        ui->ui_ctlr, ui->ui_unit);
        !          1546:                mscp_printevent(mp);
        !          1547:                ra->ra_state = CLOSED;
        !          1548:                return (MSCP_FAILED);
        !          1549:        }
        !          1550: 
        !          1551:        ra->ra_state = OPENRAW;
        !          1552:        ra->ra_dsize = (daddr_t)mp->mscp_onle.onle_unitsize;
        !          1553:        if (!cold)
        !          1554:                printf("ra%d: uda%d, unit %d, size = %d sectors\n", ui->ui_unit,
        !          1555:                    ui->ui_ctlr, mp->mscp_unit, ra->ra_dsize);
        !          1556:        /* can now compute ncyl */
        !          1557:        ra->ra_geom.rg_ncyl = ra->ra_dsize / ra->ra_geom.rg_ntracks /
        !          1558:                ra->ra_geom.rg_nsectors;
        !          1559:        return (MSCP_DONE);
        !          1560: }
        !          1561: 
        !          1562: /*
        !          1563:  * We got some (configured) unit's status.  Return DONE if it succeeded.
        !          1564:  */
        !          1565: udagotstatus(ui, mp)
        !          1566:        register struct uba_device *ui;
        !          1567:        register struct mscp *mp;
        !          1568: {
        !          1569: 
        !          1570:        if ((mp->mscp_status & M_ST_MASK) != M_ST_SUCCESS) {
        !          1571:                printf("uda%d: attempt to get status for ra%d failed: ",
        !          1572:                        ui->ui_ctlr, ui->ui_unit);
        !          1573:                mscp_printevent(mp);
        !          1574:                return (MSCP_FAILED);
        !          1575:        }
        !          1576:        /* record for (future) bad block forwarding and whatever else */
        !          1577:        uda_rasave(ui->ui_unit, mp, 1);
        !          1578:        return (MSCP_DONE);
        !          1579: }
        !          1580: 
        !          1581: /*
        !          1582:  * A transfer failed.  We get a chance to fix or restart it.
        !          1583:  * Need to write the bad block forwaring code first....
        !          1584:  */
        !          1585: /*ARGSUSED*/
        !          1586: udaioerror(ui, mp, bp)
        !          1587:        register struct uba_device *ui;
        !          1588:        register struct mscp *mp;
        !          1589:        struct buf *bp;
        !          1590: {
        !          1591: 
        !          1592:        if (mp->mscp_flags & M_EF_BBLKR) {
        !          1593:                /*
        !          1594:                 * A bad block report.  Eventually we will
        !          1595:                 * restart this transfer, but for now, just
        !          1596:                 * log it and give up.
        !          1597:                 */
        !          1598:                log(LOG_ERR, "ra%d: bad block report: %d%s\n",
        !          1599:                        ui->ui_unit, mp->mscp_seq.seq_lbn,
        !          1600:                        mp->mscp_flags & M_EF_BBLKU ? " + others" : "");
        !          1601:        } else {
        !          1602:                /*
        !          1603:                 * What the heck IS a `serious exception' anyway?
        !          1604:                 * IT SURE WOULD BE NICE IF DEC SOLD DOCUMENTATION
        !          1605:                 * FOR THEIR OWN CONTROLLERS.
        !          1606:                 */
        !          1607:                if (mp->mscp_flags & M_EF_SEREX)
        !          1608:                        log(LOG_ERR, "ra%d: serious exception reported\n",
        !          1609:                                ui->ui_unit);
        !          1610:        }
        !          1611:        return (MSCP_FAILED);
        !          1612: }
        !          1613: 
        !          1614: /*
        !          1615:  * A replace operation finished.
        !          1616:  */
        !          1617: /*ARGSUSED*/
        !          1618: udareplace(ui, mp)
        !          1619:        struct uba_device *ui;
        !          1620:        struct mscp *mp;
        !          1621: {
        !          1622: 
        !          1623:        panic("udareplace");
        !          1624: }
        !          1625: 
        !          1626: /*
        !          1627:  * A bad block related operation finished.
        !          1628:  */
        !          1629: /*ARGSUSED*/
        !          1630: udabb(ui, mp, bp)
        !          1631:        struct uba_device *ui;
        !          1632:        struct mscp *mp;
        !          1633:        struct buf *bp;
        !          1634: {
        !          1635: 
        !          1636:        panic("udabb");
        !          1637: }
        !          1638: 
        !          1639: 
        !          1640: /*
        !          1641:  * I/O controls.
        !          1642:  */
        !          1643: udaioctl(dev, cmd, data, flag)
        !          1644:        dev_t dev;
        !          1645:        int cmd;
        !          1646:        caddr_t data;
        !          1647:        int flag;
        !          1648: {
        !          1649:        register int unit = udaunit(dev);
        !          1650:        register struct disklabel *lp;
        !          1651:        register struct ra_info *ra = &ra_info[unit];
        !          1652:        int error = 0;
        !          1653: 
        !          1654:        lp = &udalabel[unit];
        !          1655: 
        !          1656:        switch (cmd) {
        !          1657: 
        !          1658:        case DIOCGDINFO:
        !          1659:                *(struct disklabel *)data = *lp;
        !          1660:                break;
        !          1661: 
        !          1662:        case DIOCGPART:
        !          1663:                ((struct partinfo *)data)->disklab = lp;
        !          1664:                ((struct partinfo *)data)->part =
        !          1665:                    &lp->d_partitions[udapart(dev)];
        !          1666:                break;
        !          1667: 
        !          1668:        case DIOCSDINFO:
        !          1669:                if ((flag & FWRITE) == 0)
        !          1670:                        error = EBADF;
        !          1671:                else
        !          1672:                        error = setdisklabel(lp, (struct disklabel *)data,
        !          1673:                            (ra->ra_state == OPENRAW) ? 0 : ra->ra_openpart);
        !          1674:                break;
        !          1675: 
        !          1676:        case DIOCWLABEL:
        !          1677:                if ((flag & FWRITE) == 0)
        !          1678:                        error = EBADF;
        !          1679:                else
        !          1680:                        ra->ra_wlabel = *(int *)data;
        !          1681:                break;
        !          1682: 
        !          1683:        case DIOCWDINFO:
        !          1684:                if ((flag & FWRITE) == 0)
        !          1685:                        error = EBADF;
        !          1686:                else if ((error = setdisklabel(lp, (struct disklabel *)data,
        !          1687:                    (ra->ra_state == OPENRAW) ? 0 : ra->ra_openpart)) == 0) {
        !          1688:                        int wlab;
        !          1689: 
        !          1690:                        ra->ra_state = OPEN;
        !          1691:                        /* simulate opening partition 0 so write succeeds */
        !          1692:                        ra->ra_openpart |= (1 << 0);            /* XXX */
        !          1693:                        wlab = ra->ra_wlabel;
        !          1694:                        ra->ra_wlabel = 1;
        !          1695:                        error = writedisklabel(dev, udastrategy, lp);
        !          1696:                        ra->ra_openpart = ra->ra_copenpart | ra->ra_bopenpart;
        !          1697:                        ra->ra_wlabel = wlab;
        !          1698:                }
        !          1699:                break;
        !          1700: 
        !          1701: #ifdef notyet
        !          1702:        case UDAIOCREPLACE:
        !          1703:                /*
        !          1704:                 * Initiate bad block replacement for the given LBN.
        !          1705:                 * (Should we allow modifiers?)
        !          1706:                 */
        !          1707:                error = EOPNOTSUPP;
        !          1708:                break;
        !          1709: 
        !          1710:        case UDAIOCGMICRO:
        !          1711:                /*
        !          1712:                 * Return the microcode revision for the UDA50 running
        !          1713:                 * this drive.
        !          1714:                 */
        !          1715:                *(int *)data = uda_softc[uddinfo[unit]->ui_ctlr].sc_micro;
        !          1716:                break;
        !          1717: #endif
        !          1718: 
        !          1719:        default:
        !          1720:                error = ENOTTY;
        !          1721:                break;
        !          1722:        }
        !          1723:        return (error);
        !          1724: }
        !          1725: 
        !          1726: /*
        !          1727:  * A Unibus reset has occurred on UBA uban.  Reinitialise the controller(s)
        !          1728:  * on that Unibus, and requeue outstanding I/O.
        !          1729:  */
        !          1730: udareset(uban)
        !          1731:        int uban;
        !          1732: {
        !          1733:        register struct uba_ctlr *um;
        !          1734:        register struct uda_softc *sc;
        !          1735:        register int ctlr;
        !          1736: 
        !          1737:        for (ctlr = 0, sc = uda_softc; ctlr < NUDA; ctlr++, sc++) {
        !          1738:                if ((um = udaminfo[ctlr]) == NULL || um->um_ubanum != uban ||
        !          1739:                    um->um_alive == 0)
        !          1740:                        continue;
        !          1741:                printf(" uda%d", ctlr);
        !          1742: 
        !          1743:                /*
        !          1744:                 * Our BDP (if any) is gone; our command (if any) is
        !          1745:                 * flushed; the device is no longer mapped; and the
        !          1746:                 * UDA50 is not yet initialised.
        !          1747:                 */
        !          1748:                if (um->um_bdp) {
        !          1749:                        printf("<%d>", UBAI_BDP(um->um_bdp));
        !          1750:                        um->um_bdp = 0;
        !          1751:                }
        !          1752:                um->um_ubinfo = 0;
        !          1753:                um->um_cmd = 0;
        !          1754:                sc->sc_flags &= ~SC_MAPPED;
        !          1755:                sc->sc_state = ST_IDLE;
        !          1756: 
        !          1757:                /* reset queues and requeue pending transfers */
        !          1758:                mscp_requeue(&sc->sc_mi);
        !          1759: 
        !          1760:                /*
        !          1761:                 * If it fails to initialise we will notice later and
        !          1762:                 * try again (and again...).  Do not call udastart()
        !          1763:                 * here; it will be done after the controller finishes
        !          1764:                 * initialisation.
        !          1765:                 */
        !          1766:                if (udainit(ctlr))
        !          1767:                        printf(" (hung)");
        !          1768:        }
        !          1769: }
        !          1770: 
        !          1771: /*
        !          1772:  * Watchdog timer:  If the controller is active, and no interrupts
        !          1773:  * have occurred for 30 seconds, assume it has gone away.
        !          1774:  */
        !          1775: udawatch()
        !          1776: {
        !          1777:        register int i;
        !          1778:        register struct uba_ctlr *um;
        !          1779:        register struct uda_softc *sc;
        !          1780: 
        !          1781:        timeout(udawatch, (caddr_t) 0, hz);     /* every second */
        !          1782:        for (i = 0, sc = uda_softc; i < NUDA; i++, sc++) {
        !          1783:                if ((um = udaminfo[i]) == 0 || !um->um_alive)
        !          1784:                        continue;
        !          1785:                if (sc->sc_state == ST_IDLE)
        !          1786:                        continue;
        !          1787:                if (sc->sc_state == ST_RUN && !um->um_tab.b_active)
        !          1788:                        sc->sc_wticks = 0;
        !          1789:                else if (++sc->sc_wticks >= 30) {
        !          1790:                        sc->sc_wticks = 0;
        !          1791:                        printf("uda%d: lost interrupt\n", i);
        !          1792:                        ubareset(um->um_ubanum);
        !          1793:                }
        !          1794:        }
        !          1795: }
        !          1796: 
        !          1797: /*
        !          1798:  * Do a panic dump.  We set up the controller for one command packet
        !          1799:  * and one response packet, for which we use `struct uda1'.
        !          1800:  */
        !          1801: struct uda1 {
        !          1802:        struct  uda1ca uda1_ca; /* communications area */
        !          1803:        struct  mscp uda1_rsp;  /* response packet */
        !          1804:        struct  mscp uda1_cmd;  /* command packet */
        !          1805: } uda1;
        !          1806: 
        !          1807: #define        DBSIZE  32              /* dump 16K at a time */
        !          1808: 
        !          1809: udadump(dev)
        !          1810:        dev_t dev;
        !          1811: {
        !          1812:        struct udadevice *udaddr;
        !          1813:        struct uda1 *ud_ubaddr;
        !          1814:        char *start;
        !          1815:        int num, blk, unit, maxsz, blkoff, reg;
        !          1816:        struct partition *pp;
        !          1817:        register struct uba_regs *uba;
        !          1818:        register struct uba_device *ui;
        !          1819:        register struct uda1 *ud;
        !          1820:        register struct pte *io;
        !          1821:        register int i;
        !          1822: 
        !          1823:        /*
        !          1824:         * Make sure the device is a reasonable place on which to dump.
        !          1825:         */
        !          1826:        unit = udaunit(dev);
        !          1827:        if (unit >= NRA)
        !          1828:                return (ENXIO);
        !          1829: #define        phys(cast, addr)        ((cast) ((int)addr & 0x7fffffff))
        !          1830:        ui = phys(struct uba_device *, udadinfo[unit]);
        !          1831:        if (ui == NULL || ui->ui_alive == 0)
        !          1832:                return (ENXIO);
        !          1833: 
        !          1834:        /*
        !          1835:         * Find and initialise the UBA; get the physical address of the
        !          1836:         * device registers, and of communications area and command and
        !          1837:         * response packet.
        !          1838:         */
        !          1839:        uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
        !          1840:        ubainit(uba);
        !          1841:        udaddr = (struct udadevice *)ui->ui_physaddr;
        !          1842:        ud = phys(struct uda1 *, &uda1);
        !          1843: 
        !          1844:        /*
        !          1845:         * Map the ca+packets into Unibus I/O space so the UDA50 can get
        !          1846:         * at them.  Use the registers at the end of the Unibus map (since
        !          1847:         * we will use the registers at the beginning to map the memory
        !          1848:         * we are dumping).
        !          1849:         */
        !          1850:        num = btoc(sizeof(struct uda1)) + 1;
        !          1851:        reg = NUBMREG - num;
        !          1852:        io = &uba->uba_map[reg];
        !          1853:        for (i = 0; i < num; i++)
        !          1854:                *(int *)io++ = UBAMR_MRV | (btop(ud) + i);
        !          1855:        ud_ubaddr = (struct uda1 *)(((int)ud & PGOFSET) | (reg << 9));
        !          1856: 
        !          1857:        /*
        !          1858:         * Initialise the controller, with one command and one response
        !          1859:         * packet.
        !          1860:         */
        !          1861:        udaddr->udaip = 0;
        !          1862:        if (udadumpwait(udaddr, UDA_STEP1))
        !          1863:                return (EFAULT);
        !          1864:        udaddr->udasa = UDA_ERR;
        !          1865:        if (udadumpwait(udaddr, UDA_STEP2))
        !          1866:                return (EFAULT);
        !          1867:        udaddr->udasa = (int)&ud_ubaddr->uda1_ca.ca_rspdsc;
        !          1868:        if (udadumpwait(udaddr, UDA_STEP3))
        !          1869:                return (EFAULT);
        !          1870:        udaddr->udasa = ((int)&ud_ubaddr->uda1_ca.ca_rspdsc) >> 16;
        !          1871:        if (udadumpwait(udaddr, UDA_STEP4))
        !          1872:                return (EFAULT);
        !          1873:        uda_softc[ui->ui_ctlr].sc_micro = udaddr->udasa & 0xff;
        !          1874:        udaddr->udasa = UDA_GO;
        !          1875: 
        !          1876:        /*
        !          1877:         * Set up the command and response descriptor, then set the
        !          1878:         * controller characteristics and bring the drive on line.
        !          1879:         * Note that all uninitialised locations in uda1_cmd are zero.
        !          1880:         */
        !          1881:        ud->uda1_ca.ca_rspdsc = (long)&ud_ubaddr->uda1_rsp.mscp_cmdref;
        !          1882:        ud->uda1_ca.ca_cmddsc = (long)&ud_ubaddr->uda1_cmd.mscp_cmdref;
        !          1883:        /* ud->uda1_cmd.mscp_sccc.sccc_ctlrflags = 0; */
        !          1884:        /* ud->uda1_cmd.mscp_sccc.sccc_version = 0; */
        !          1885:        if (udadumpcmd(M_OP_SETCTLRC, ud, ui))
        !          1886:                return (EFAULT);
        !          1887:        ud->uda1_cmd.mscp_unit = ui->ui_slave;
        !          1888:        if (udadumpcmd(M_OP_ONLINE, ud, ui))
        !          1889:                return (EFAULT);
        !          1890: 
        !          1891:        pp = phys(struct partition *,
        !          1892:            &udalabel[unit].d_partitions[udapart(dev)]);
        !          1893:        maxsz = pp->p_size;
        !          1894:        blkoff = pp->p_offset;
        !          1895: 
        !          1896:        /*
        !          1897:         * Dump all of physical memory, or as much as will fit in the
        !          1898:         * space provided.
        !          1899:         */
        !          1900:        start = 0;
        !          1901:        num = maxfree;
        !          1902:        if (dumplo < 0)
        !          1903:                return (EINVAL);
        !          1904:        if (dumplo + num >= maxsz)
        !          1905:                num = maxsz - dumplo;
        !          1906:        blkoff += dumplo;
        !          1907: 
        !          1908:        /*
        !          1909:         * Write out memory, DBSIZE pages at a time.
        !          1910:         * N.B.: this code depends on the fact that the sector
        !          1911:         * size == the page size.
        !          1912:         */
        !          1913:        while (num > 0) {
        !          1914:                blk = num > DBSIZE ? DBSIZE : num;
        !          1915:                io = uba->uba_map;
        !          1916:                /*
        !          1917:                 * Map in the pages to write, leaving an invalid entry
        !          1918:                 * at the end to guard against wild Unibus transfers.
        !          1919:                 * Then do the write.
        !          1920:                 */
        !          1921:                for (i = 0; i < blk; i++)
        !          1922:                        *(int *)io++ = UBAMR_MRV | (btop(start) + i);
        !          1923:                *(int *)io = 0;
        !          1924:                ud->uda1_cmd.mscp_unit = ui->ui_slave;
        !          1925:                ud->uda1_cmd.mscp_seq.seq_lbn = btop(start) + blkoff;
        !          1926:                ud->uda1_cmd.mscp_seq.seq_bytecount = blk << PGSHIFT;
        !          1927:                if (udadumpcmd(M_OP_WRITE, ud, ui))
        !          1928:                        return (EIO);
        !          1929:                start += blk << PGSHIFT;
        !          1930:                num -= blk;
        !          1931:        }
        !          1932:        return (0);             /* made it! */
        !          1933: }
        !          1934: 
        !          1935: /*
        !          1936:  * Wait for some of the bits in `bits' to come on.  If the error bit
        !          1937:  * comes on, or ten seconds pass without response, return true (error).
        !          1938:  */
        !          1939: udadumpwait(udaddr, bits)
        !          1940:        register struct udadevice *udaddr;
        !          1941:        register int bits;
        !          1942: {
        !          1943:        register int timo = todr() + 1000;
        !          1944: 
        !          1945:        while ((udaddr->udasa & bits) == 0) {
        !          1946:                if (udaddr->udasa & UDA_ERR) {
        !          1947:                        printf("udasa=%b\ndump ", udaddr->udasa, udasr_bits);
        !          1948:                        return (1);
        !          1949:                }
        !          1950:                if (todr() >= timo) {
        !          1951:                        printf("timeout\ndump ");
        !          1952:                        return (1);
        !          1953:                }
        !          1954:        }
        !          1955:        return (0);
        !          1956: }
        !          1957: 
        !          1958: /*
        !          1959:  * Feed a command to the UDA50, wait for its response, and return
        !          1960:  * true iff something went wrong.
        !          1961:  */
        !          1962: udadumpcmd(op, ud, ui)
        !          1963:        int op;
        !          1964:        register struct uda1 *ud;
        !          1965:        struct uba_device *ui;
        !          1966: {
        !          1967:        register struct udadevice *udaddr;
        !          1968:        register int n;
        !          1969: #define mp (&ud->uda1_rsp)
        !          1970: 
        !          1971:        udaddr = (struct udadevice *)ui->ui_physaddr;
        !          1972:        ud->uda1_cmd.mscp_opcode = op;
        !          1973:        ud->uda1_cmd.mscp_msglen = MSCP_MSGLEN;
        !          1974:        ud->uda1_rsp.mscp_msglen = MSCP_MSGLEN;
        !          1975:        ud->uda1_ca.ca_rspdsc |= MSCP_OWN | MSCP_INT;
        !          1976:        ud->uda1_ca.ca_cmddsc |= MSCP_OWN | MSCP_INT;
        !          1977:        if (udaddr->udasa & UDA_ERR) {
        !          1978:                printf("udasa=%b\ndump ", udaddr->udasa, udasr_bits);
        !          1979:                return (1);
        !          1980:        }
        !          1981:        n = udaddr->udaip;
        !          1982:        n = todr() + 1000;
        !          1983:        for (;;) {
        !          1984:                if (todr() > n) {
        !          1985:                        printf("timeout\ndump ");
        !          1986:                        return (1);
        !          1987:                }
        !          1988:                if (ud->uda1_ca.ca_cmdint)
        !          1989:                        ud->uda1_ca.ca_cmdint = 0;
        !          1990:                if (ud->uda1_ca.ca_rspint == 0)
        !          1991:                        continue;
        !          1992:                ud->uda1_ca.ca_rspint = 0;
        !          1993:                if (mp->mscp_opcode == (op | M_OP_END))
        !          1994:                        break;
        !          1995:                printf("\n");
        !          1996:                switch (MSCP_MSGTYPE(mp->mscp_msgtc)) {
        !          1997: 
        !          1998:                case MSCPT_SEQ:
        !          1999:                        printf("sequential");
        !          2000:                        break;
        !          2001: 
        !          2002:                case MSCPT_DATAGRAM:
        !          2003:                        mscp_decodeerror("uda", ui->ui_ctlr, mp);
        !          2004:                        printf("datagram");
        !          2005:                        break;
        !          2006: 
        !          2007:                case MSCPT_CREDITS:
        !          2008:                        printf("credits");
        !          2009:                        break;
        !          2010: 
        !          2011:                case MSCPT_MAINTENANCE:
        !          2012:                        printf("maintenance");
        !          2013:                        break;
        !          2014: 
        !          2015:                default:
        !          2016:                        printf("unknown (type 0x%x)",
        !          2017:                                MSCP_MSGTYPE(mp->mscp_msgtc));
        !          2018:                        break;
        !          2019:                }
        !          2020:                printf(" ignored\ndump ");
        !          2021:                ud->uda1_ca.ca_rspdsc |= MSCP_OWN | MSCP_INT;
        !          2022:        }
        !          2023:        if ((mp->mscp_status & M_ST_MASK) != M_ST_SUCCESS) {
        !          2024:                printf("error: op 0x%x => 0x%x status 0x%x\ndump ", op,
        !          2025:                        mp->mscp_opcode, mp->mscp_status);
        !          2026:                return (1);
        !          2027:        }
        !          2028:        return (0);
        !          2029: #undef mp
        !          2030: }
        !          2031: 
        !          2032: /*
        !          2033:  * Return the size of a partition, if known, or -1 if not.
        !          2034:  */
        !          2035: udasize(dev)
        !          2036:        dev_t dev;
        !          2037: {
        !          2038:        register int unit = udaunit(dev);
        !          2039:        register struct uba_device *ui;
        !          2040: 
        !          2041:        if (unit >= NRA || (ui = udadinfo[unit]) == NULL ||
        !          2042:            ui->ui_alive == 0 || (ui->ui_flags & UNIT_ONLINE) == 0 ||
        !          2043:            ra_info[unit].ra_state != OPEN)
        !          2044:                return (-1);
        !          2045:        return ((int)udalabel[unit].d_partitions[udapart(dev)].p_size);
        !          2046: }
        !          2047: 
        !          2048: #ifdef COMPAT_42
        !          2049: /*
        !          2050:  * Tables mapping unlabelled drives.
        !          2051:  */
        !          2052: struct size {
        !          2053:        daddr_t nblocks;
        !          2054:        daddr_t blkoff;
        !          2055: } ra60_sizes[8] = {
        !          2056:        15884,  0,              /* A=sectors 0 thru 15883 */
        !          2057:        33440,  15884,          /* B=sectors 15884 thru 49323 */
        !          2058:        400176, 0,              /* C=sectors 0 thru 400175 */
        !          2059:        82080,  49324,          /* 4.2 G => D=sectors 49324 thru 131403 */
        !          2060:        268772, 131404,         /* 4.2 H => E=sectors 131404 thru 400175 */
        !          2061:        350852, 49324,          /* F=sectors 49324 thru 400175 */
        !          2062:        157570, 242606,         /* UCB G => G=sectors 242606 thru 400175 */
        !          2063:        193282, 49324,          /* UCB H => H=sectors 49324 thru 242605 */
        !          2064: }, ra70_sizes[8] = {
        !          2065:        15884,  0,              /* A=blk 0 thru 15883 */
        !          2066:        33440,  15972,          /* B=blk 15972 thru 49323 */
        !          2067:        -1,     0,              /* C=blk 0 thru end */
        !          2068:        15884,  341220,         /* D=blk 341220 thru 357103 */
        !          2069:        55936,  357192,         /* E=blk 357192 thru 413127 */
        !          2070:        -1,     413457,         /* F=blk 413457 thru end */
        !          2071:        -1,     341220,         /* G=blk 341220 thru end */
        !          2072:        291346, 49731,          /* H=blk 49731 thru 341076 */
        !          2073: }, ra80_sizes[8] = {
        !          2074:        15884,  0,              /* A=sectors 0 thru 15883 */
        !          2075:        33440,  15884,          /* B=sectors 15884 thru 49323 */
        !          2076:        242606, 0,              /* C=sectors 0 thru 242605 */
        !          2077:        0,      0,              /* D=unused */
        !          2078:        193282, 49324,          /* UCB H => E=sectors 49324 thru 242605 */
        !          2079:        82080,  49324,          /* 4.2 G => F=sectors 49324 thru 131403 */
        !          2080:        192696, 49910,          /* G=sectors 49910 thru 242605 */
        !          2081:        111202, 131404,         /* 4.2 H => H=sectors 131404 thru 242605 */
        !          2082: }, ra81_sizes[8] ={
        !          2083: #ifdef MARYLAND
        !          2084: #ifdef ENEEVAX
        !          2085:        30706,  0,              /* A=cyl    0 thru   42 + 2 sectors */
        !          2086:        40696,  30706,          /* B=cyl   43 thru   99 - 2 sectors */
        !          2087:        -1,     0,              /* C=cyl    0 thru 1247 */
        !          2088:        -1,     71400,          /* D=cyl  100 thru 1247 */
        !          2089: 
        !          2090:        15884,  0,              /* E=blk      0 thru  15883 */
        !          2091:        33440,  15884,          /* F=blk  15884 thru  49323 */
        !          2092:        82080,  49324,          /* G=blk  49324 thru 131403 */
        !          2093:        -1,     131404,         /* H=blk 131404 thru    end */
        !          2094: #else
        !          2095:        67832,  0,              /* A=cyl    0 thru   94 + 2 sectors */
        !          2096:        67828,  67832,          /* B=cyl   95 thru  189 - 2 sectors */
        !          2097:        -1,     0,              /* C=cyl    0 thru 1247 */
        !          2098:        -1,     135660,         /* D=cyl  190 thru 1247 */
        !          2099:        0,      0,
        !          2100:        0,      0,
        !          2101:        0,      0,
        !          2102:        0,      0,
        !          2103: #endif ENEEVAX
        !          2104: #else
        !          2105: /*
        !          2106:  * These are the new standard partition sizes for ra81's.
        !          2107:  * An RA_COMPAT system is compiled with D, E, and F corresponding
        !          2108:  * to the 4.2 partitions for G, H, and F respectively.
        !          2109:  */
        !          2110: #ifndef        UCBRA
        !          2111:        15884,  0,              /* A=sectors 0 thru 15883 */
        !          2112:        66880,  16422,          /* B=sectors 16422 thru 83301 */
        !          2113:        891072, 0,              /* C=sectors 0 thru 891071 */
        !          2114: #ifdef RA_COMPAT
        !          2115:        82080,  49324,          /* 4.2 G => D=sectors 49324 thru 131403 */
        !          2116:        759668, 131404,         /* 4.2 H => E=sectors 131404 thru 891071 */
        !          2117:        478582, 412490,         /* 4.2 F => F=sectors 412490 thru 891071 */
        !          2118: #else
        !          2119:        15884,  375564,         /* D=sectors 375564 thru 391447 */
        !          2120:        307200, 391986,         /* E=sectors 391986 thru 699185 */
        !          2121:        191352, 699720,         /* F=sectors 699720 thru 891071 */
        !          2122: #endif RA_COMPAT
        !          2123:        515508, 375564,         /* G=sectors 375564 thru 891071 */
        !          2124:        291346, 83538,          /* H=sectors 83538 thru 374883 */
        !          2125: 
        !          2126: /*
        !          2127:  * These partitions correspond to the sizes used by sites at Berkeley,
        !          2128:  * and by those sites that have received copies of the Berkeley driver
        !          2129:  * with deltas 6.2 or greater (11/15/83).
        !          2130:  */
        !          2131: #else UCBRA
        !          2132: 
        !          2133:        15884,  0,              /* A=sectors 0 thru 15883 */
        !          2134:        33440,  15884,          /* B=sectors 15884 thru 49323 */
        !          2135:        891072, 0,              /* C=sectors 0 thru 891071 */
        !          2136:        15884,  242606,         /* D=sectors 242606 thru 258489 */
        !          2137:        307200, 258490,         /* E=sectors 258490 thru 565689 */
        !          2138:        325382, 565690,         /* F=sectors 565690 thru 891071 */
        !          2139:        648466, 242606,         /* G=sectors 242606 thru 891071 */
        !          2140:        193282, 49324,          /* H=sectors 49324 thru 242605 */
        !          2141: 
        !          2142: #endif UCBRA
        !          2143: #endif MARYLAND
        !          2144: }, ra82_sizes[8] = {
        !          2145:        15884,  0,              /* A=blk 0 thru 15883 */
        !          2146:        66880,  16245,          /* B=blk 16245 thru 83124 */
        !          2147:        -1,     0,              /* C=blk 0 thru end */
        !          2148:        15884,  375345,         /* D=blk 375345 thru 391228 */
        !          2149:        307200, 391590,         /* E=blk 391590 thru 698789 */
        !          2150:        -1,     699390,         /* F=blk 699390 thru end */
        !          2151:        -1,     375345,         /* G=blk 375345 thru end */
        !          2152:        291346, 83790,          /* H=blk 83790 thru 375135 */
        !          2153: }, rc25_sizes[8] = {
        !          2154:        15884,  0,              /* A=blk 0 thru 15883 */
        !          2155:        10032,  15884,          /* B=blk 15884 thru 49323 */
        !          2156:        -1,     0,              /* C=blk 0 thru end */
        !          2157:        0,      0,              /* D=blk 340670 thru 356553 */
        !          2158:        0,      0,              /* E=blk 356554 thru 412489 */
        !          2159:        0,      0,              /* F=blk 412490 thru end */
        !          2160:        -1,     25916,          /* G=blk 49324 thru 131403 */
        !          2161:        0,      0,              /* H=blk 131404 thru end */
        !          2162: }, rd52_sizes[8] = {
        !          2163:        15884,  0,              /* A=blk 0 thru 15883 */
        !          2164:        9766,   15884,          /* B=blk 15884 thru 25649 */
        !          2165:        -1,     0,              /* C=blk 0 thru end */
        !          2166:        0,      0,              /* D=unused */
        !          2167:        0,      0,              /* E=unused */
        !          2168:        0,      0,              /* F=unused */
        !          2169:        -1,     25650,          /* G=blk 25650 thru end */
        !          2170:        0,      0,              /* H=unused */
        !          2171: }, rd53_sizes[8] = {
        !          2172:        15884,  0,              /* A=blk 0 thru 15883 */
        !          2173:        33440,  15884,          /* B=blk 15884 thru 49323 */
        !          2174:        -1,     0,              /* C=blk 0 thru end */
        !          2175:        0,      0,              /* D=unused */
        !          2176:        33440,  0,              /* E=blk 0 thru 33439 */
        !          2177:        -1,     33440,          /* F=blk 33440 thru end */
        !          2178:        -1,     49324,          /* G=blk 49324 thru end */
        !          2179:        -1,     15884,          /* H=blk 15884 thru end */
        !          2180: }, rx50_sizes[8] = {
        !          2181:        800,    0,              /* A=blk 0 thru 799 */
        !          2182:        0,      0,
        !          2183:        -1,     0,              /* C=blk 0 thru end */
        !          2184:        0,      0,
        !          2185:        0,      0,
        !          2186:        0,      0,
        !          2187:        0,      0,
        !          2188:        0,      0,
        !          2189: };
        !          2190: 
        !          2191: /*
        !          2192:  * Media ID decoding table.
        !          2193:  */
        !          2194: struct udatypes {
        !          2195:        u_long  ut_id;          /* media drive ID */
        !          2196:        char    *ut_name;       /* drive type name */
        !          2197:        struct  size *ut_sizes; /* partition tables */
        !          2198:        int     ut_nsectors, ut_ntracks, ut_ncylinders;
        !          2199: } udatypes[] = {
        !          2200:        { MSCP_MKDRIVE2('R', 'A', 60), "ra60", ra60_sizes, 42, 4, 2382 },
        !          2201:        { MSCP_MKDRIVE2('R', 'A', 70), "ra70", ra70_sizes, 33, 11, 1507 },
        !          2202:        { MSCP_MKDRIVE2('R', 'A', 80), "ra80", ra80_sizes, 31, 14, 559 },
        !          2203:        { MSCP_MKDRIVE2('R', 'A', 81), "ra81", ra81_sizes, 51, 14, 1248 },
        !          2204:        { MSCP_MKDRIVE2('R', 'A', 82), "ra82", ra82_sizes, 57, 14, 1423 },
        !          2205:        { MSCP_MKDRIVE2('R', 'C', 25), "rc25-removable",
        !          2206:                                                rc25_sizes, 42, 4, 302 },
        !          2207:        { MSCP_MKDRIVE3('R', 'C', 'F', 25), "rc25-fixed",
        !          2208:                                                rc25_sizes, 42, 4, 302 },
        !          2209:        { MSCP_MKDRIVE2('R', 'D', 52), "rd52", rd52_sizes, 18, 7, 480 },
        !          2210:        { MSCP_MKDRIVE2('R', 'D', 53), "rd53", rd53_sizes, 18, 8, 963 },
        !          2211:        { MSCP_MKDRIVE2('R', 'X', 50), "rx50", rx50_sizes, 10, 1, 80 },
        !          2212:        0
        !          2213: };
        !          2214: 
        !          2215: #define NTYPES (sizeof(udatypes) / sizeof(*udatypes))
        !          2216: 
        !          2217: udamaptype(unit, lp)
        !          2218:        int unit;
        !          2219:        register struct disklabel *lp;
        !          2220: {
        !          2221:        register struct udatypes *ut;
        !          2222:        register struct size *sz;
        !          2223:        register struct partition *pp;
        !          2224:        register char *p;
        !          2225:        register int i;
        !          2226:        register struct ra_info *ra = &ra_info[unit];
        !          2227: 
        !          2228:        lp->d_secsize = 512;
        !          2229:        lp->d_secperunit = ra->ra_dsize;
        !          2230:        i = MSCP_MEDIA_DRIVE(ra->ra_mediaid);
        !          2231:        for (ut = udatypes; ut->ut_id; ut++)
        !          2232:                if (ut->ut_id == i)
        !          2233:                        goto found;
        !          2234: 
        !          2235:        /* not one we know; fake up a label for the whole drive */
        !          2236:        lp->d_nsectors = ra->ra_geom.rg_nsectors;
        !          2237:        lp->d_ntracks = ra->ra_geom.rg_ntracks;
        !          2238:        lp->d_ncylinders = ra->ra_geom.rg_ncyl;
        !          2239:        i = ra->ra_mediaid;     /* print the port type too */
        !          2240:        if (!cold)
        !          2241:                log(LOG_ERR, "ra%d", unit);
        !          2242:        addlog(": don't have a partition table for %c%c %c%c%c%d;\n\
        !          2243: using (s,t,c)=(%d,%d,%d)",
        !          2244:                MSCP_MID_CHAR(4, i), MSCP_MID_CHAR(3, i),
        !          2245:                MSCP_MID_CHAR(2, i), MSCP_MID_CHAR(1, i),
        !          2246:                MSCP_MID_CHAR(0, i), MSCP_MID_CHAR(0, i),
        !          2247:                MSCP_MID_NUM(i), lp->d_nsectors,
        !          2248:                lp->d_ntracks, lp->d_ncylinders);
        !          2249:        if (!cold)
        !          2250:                addlog("\n");
        !          2251:        lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
        !          2252:        lp->d_typename[0] = 'r';
        !          2253:        lp->d_typename[1] = 'a';
        !          2254:        lp->d_typename[2] = '?';
        !          2255:        lp->d_typename[3] = '?';
        !          2256:        lp->d_typename[4] = 0;
        !          2257:        lp->d_npartitions = 1;
        !          2258:        lp->d_partitions[0].p_offset = 0;
        !          2259:        lp->d_partitions[0].p_size = lp->d_secperunit;
        !          2260:        return (0);
        !          2261: found:
        !          2262:        p = ut->ut_name;
        !          2263:        for (i = 0; i < sizeof(lp->d_typename) - 1 && *p; i++)
        !          2264:                lp->d_typename[i] = *p++;
        !          2265:        lp->d_typename[i] = 0;
        !          2266:        sz = ut->ut_sizes;
        !          2267:        /* GET nsectors, ntracks, ncylinders FROM SAVED GEOMETRY? */
        !          2268:        lp->d_nsectors = ut->ut_nsectors;
        !          2269:        lp->d_ntracks = ut->ut_ntracks;
        !          2270:        lp->d_ncylinders = ut->ut_ncylinders;
        !          2271:        lp->d_npartitions = 8;
        !          2272:        lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
        !          2273:        for (pp = lp->d_partitions; pp < &lp->d_partitions[8]; pp++, sz++) {
        !          2274:                pp->p_offset = sz->blkoff;
        !          2275:                if ((pp->p_size = sz->nblocks) == (u_long)-1)
        !          2276:                        pp->p_size = ra->ra_dsize - sz->blkoff;
        !          2277:        }
        !          2278:        return (1);
        !          2279: }
        !          2280: #endif /* COMPAT_42 */
        !          2281: #endif /* NUDA > 0 */

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