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