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