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 * Computer Consoles Inc.
7 *
8 * %sccs.include.redist.c%
9 *
10 * @(#)vd.c 7.15 (Berkeley) 07/23/92
11 */
12
13 #include "dk.h"
14 #if NVD > 0
15 /*
16 * Versabus VDDC/SMDE driver.
17 */
18 #include "sys/param.h"
19 #include "sys/buf.h"
20 #include "sys/cmap.h"
21 #include "sys/conf.h"
22 #include "sys/dkstat.h"
23 #include "sys/disklabel.h"
24 #include "sys/map.h"
25 #include "sys/file.h"
26 #include "sys/systm.h"
27 #include "sys/user.h"
28 #include "sys/vmmac.h"
29 #include "sys/proc.h"
30 #include "sys/syslog.h"
31 #include "sys/kernel.h"
32 #include "sys/ioctl.h"
33 #include "sys/stat.h"
34
35 #include "../include/cpu.h"
36 #include "../include/mtpr.h"
37 #include "../include/pte.h"
38
39 #include "../vba/vbavar.h"
40 #include "../vba/vdreg.h"
41
42 #ifndef COMPAT_42
43 #define COMPAT_42
44 #endif
45 #define B_FORMAT B_XXX /* XXX */
46
47 #define vdunit(dev) (minor(dev) >> 3)
48 #define vdpart(dev) (minor(dev) & 0x07)
49 #define vdminor(unit,part) (((unit) << 3) | (part))
50
51 struct vba_ctlr *vdminfo[NVD];
52 struct vba_device *vddinfo[NDK];
53 int vdprobe(), vdslave(), vdattach(), vddgo(), vdstrategy();
54 long vdstd[] = { 0xffff2000, 0xffff2100, 0xffff2200, 0xffff2300, 0 };
55 struct vba_driver vddriver =
56 { vdprobe, vdslave, vdattach, vddgo, vdstd, "dk", vddinfo, "vd", vdminfo };
57
58 /*
59 * Per-controller state.
60 */
61 struct vdsoftc {
62 u_short vd_flags;
63 #define VD_PRINT 0x1 /* controller info printed */
64 #define VD_STARTED 0x2 /* start command issued */
65 #define VD_DOSEEKS 0x4 /* should overlap seeks */
66 #define VD_SCATGATH 0x8 /* can do scatter-gather commands (correctly) */
67 #define VD_LOCKED 0x10 /* locked for direct controller access */
68 #define VD_WAIT 0x20 /* someone needs direct controller access */
69 u_short vd_type; /* controller type */
70 u_short vd_wticks; /* timeout */
71 u_short vd_secsize; /* sector size for controller */
72 struct mdcb vd_mdcb; /* master command block */
73 u_long vd_mdcbphys; /* physical address of vd_mdcb */
74 struct dcb vd_dcb; /* i/o command block */
75 u_long vd_dcbphys; /* physical address of vd_dcb */
76 struct vb_buf vd_rbuf; /* vba resources */
77 } vdsoftc[NVD];
78
79 #define VDMAXTIME 20 /* max time for operation, sec. */
80
81 /*
82 * Per-drive state.
83 */
84 struct dksoftc {
85 int dk_state; /* open fsm */
86 #ifndef SECSIZE
87 u_short dk_bshift; /* shift for * (DEV_BSIZE / sectorsize) XXX */
88 #endif SECSIZE
89 int dk_wlabel; /* label sector is currently writable */
90 u_long dk_copenpart; /* character units open on this drive */
91 u_long dk_bopenpart; /* block units open on this drive */
92 u_long dk_openpart; /* all units open on this drive */
93 u_int dk_curcyl; /* last selected cylinder */
94 struct skdcb dk_dcb; /* seek command block */
95 u_long dk_dcbphys; /* physical address of dk_dcb */
96 int df_reg[3]; /* for formatting, in-out parameters */
97 } dksoftc[NDK];
98
99 /*
100 * Drive states. Used during steps of open/initialization.
101 * States < OPEN (> 0) are transient, during an open operation.
102 * OPENRAW is used for unlabeled disks, to allow format operations.
103 */
104 #define CLOSED 0 /* disk is closed */
105 #define WANTOPEN 1 /* open requested, not started */
106 #define WANTOPENRAW 2 /* open requested, no label */
107 #define RDLABEL 3 /* reading pack label */
108 #define OPEN 4 /* intialized and ready */
109 #define OPENRAW 5 /* open, no label */
110
111 struct buf dkutab[NDK]; /* i/o queue headers */
112 struct disklabel dklabel[NDK]; /* pack labels */
113
114 #define b_cylin b_resid
115 #define b_track b_error /* used for seek commands */
116 #define b_seekf b_forw /* second queue on um_tab */
117 #define b_seekl b_back /* second queue on um_tab */
118
119 int vdwstart, vdwatch();
120
121 /*
122 * See if the controller is really there; if so, initialize it.
123 */
vdprobe(reg,vm)124 vdprobe(reg, vm)
125 caddr_t reg;
126 struct vba_ctlr *vm;
127 {
128 register br, cvec; /* must be r12, r11 */
129 register struct vddevice *vdaddr = (struct vddevice *)reg;
130 struct vdsoftc *vd;
131 int s;
132
133 #ifdef lint
134 br = 0; cvec = br; br = cvec;
135 vdintr(0);
136 #endif
137 if (badaddr((caddr_t)reg, 2))
138 return (0);
139 vd = &vdsoftc[vm->um_ctlr];
140 vdaddr->vdreset = 0xffffffff;
141 DELAY(1000000);
142 if (vdaddr->vdreset != (unsigned)0xffffffff) {
143 vd->vd_type = VDTYPE_VDDC;
144 vd->vd_flags &= ~VD_DOSEEKS;
145 DELAY(1000000);
146 } else {
147 vd->vd_type = VDTYPE_SMDE;
148 vd->vd_flags |= VD_DOSEEKS;
149 vdaddr->vdrstclr = 0;
150 DELAY(3000000);
151 }
152 vd->vd_mdcbphys = vtoph((struct proc *)0, (unsigned)&vd->vd_mdcb);
153 vd->vd_dcbphys = vtoph((struct proc *)0, (unsigned)&vd->vd_dcb);
154 vm->um_addr = reg; /* XXX */
155 s = spl7();
156 if (vdinit_ctlr(vm, vd) == 0) {
157 splx(s);
158 return (0);
159 }
160 if (vd->vd_type == VDTYPE_SMDE) {
161 #ifdef notdef
162 /*
163 * Attempt PROBE to get all drive status;
164 * we take advantage of this in vdreset_drive
165 * to try to avoid guessing games.
166 */
167 (void) vdcmd(vm, VDOP_PROBE, 5, 0);
168 #endif
169 /*
170 * Check for scatter-gather by checking firmware date
171 * with IDENT command. The date is printed when
172 * vdslave is first called, thus this must be
173 * the last controller operation in vdprobe.
174 */
175 vd->vd_dcb.trail.idtrail.date = 0;
176 if (vdcmd(vm, VDOP_IDENT, 10, 0)) {
177 uncache(&vd->vd_dcb.trail.idtrail.date);
178 if (vd->vd_dcb.trail.idtrail.date != 0)
179 vd->vd_flags |= VD_SCATGATH;
180 }
181 }
182 splx(s);
183 /*
184 * Allocate page tables and i/o buffer.
185 */
186 if (vbainit(&vd->vd_rbuf, MAXPHYS,
187 vd->vd_type == VDTYPE_VDDC ? VB_24BIT : VB_32BIT) == 0) {
188 printf("vd%d: vbainit failed\n", vm->um_ctlr);
189 return (0);
190 }
191 br = 0x17, cvec = 0xe0 + vm->um_ctlr; /* XXX */
192 return (sizeof (struct vddevice));
193 }
194
195 /*
196 * See if a drive is really there.
197 *
198 * Can't read pack label here as various data structures
199 * aren't setup for doing a read in a straightforward
200 * manner. Instead just probe for the drive and leave
201 * the pack label stuff to the attach routine.
202 */
203 /* ARGSUSED */
vdslave(vi,vdaddr)204 vdslave(vi, vdaddr)
205 register struct vba_device *vi;
206 struct vddevice *vdaddr;
207 {
208 register struct disklabel *lp = &dklabel[vi->ui_unit];
209 register struct dksoftc *dk = &dksoftc[vi->ui_unit];
210 struct vdsoftc *vd = &vdsoftc[vi->ui_ctlr];
211 int bcd();
212
213 if ((vd->vd_flags&VD_PRINT) == 0) {
214 printf("vd%d: %s controller", vi->ui_ctlr,
215 vd->vd_type == VDTYPE_VDDC ? "VDDC" : "SMDE");
216 if (vd->vd_flags & VD_SCATGATH) {
217 char rev[5];
218
219 bcopy((caddr_t)&vd->vd_dcb.trail.idtrail.rev, rev,
220 sizeof(vd->vd_dcb.trail.idtrail.rev));
221 printf(" firmware rev %s (%d-%d-%d)", rev,
222 bcd((vd->vd_dcb.trail.idtrail.date >> 8) & 0xff),
223 bcd(vd->vd_dcb.trail.idtrail.date & 0xff),
224 bcd((vd->vd_dcb.trail.idtrail.date >> 16)&0xffff));
225 }
226 printf("\n");
227 vd->vd_flags |= VD_PRINT;
228 }
229
230 /*
231 * Initialize label enough to do a reset on
232 * the drive. The remainder of the default
233 * label values will be filled in in vdinit
234 * at attach time.
235 */
236 if (vd->vd_type == VDTYPE_SMDE)
237 lp->d_secsize = VD_MAXSECSIZE;
238 else
239 lp->d_secsize = VDDC_SECSIZE;
240 lp->d_nsectors = 66; /* only used on smd-e */
241 lp->d_ntracks = 23;
242 lp->d_ncylinders = 850;
243 lp->d_secpercyl = 66*23;
244 lp->d_rpm = 3600;
245 lp->d_npartitions = 1;
246 lp->d_partitions[0].p_offset = 0;
247 lp->d_partitions[0].p_size = LABELSECTOR + 1;
248
249 /*
250 * Initialize invariant portion of
251 * dcb used for overlapped seeks.
252 */
253 dk->dk_dcb.opcode = VDOP_SEEK;
254 dk->dk_dcb.intflg = DCBINT_NONE | DCBINT_PBA;
255 dk->dk_dcb.devselect = vi->ui_slave;
256 dk->dk_dcb.trailcnt = sizeof (struct trseek) / sizeof (long);
257 dk->dk_dcb.trail.sktrail.skaddr.sector = 0;
258 dk->dk_dcbphys = vtoph((struct proc *)0, (unsigned)&dk->dk_dcb);
259 #ifndef SECSIZE
260 vd_setsecsize(dk, lp);
261 #endif
262 return (vdreset_drive(vi));
263 }
264
265 static int
bcd(n)266 bcd(n)
267 register u_int n;
268 {
269 register int bin = 0;
270 register int mul = 1;
271
272 while (n) {
273 bin += (n & 0xf) * mul;
274 n >>= 4;
275 mul *= 10;
276 }
277 return (bin);
278 }
279
vdattach(vi)280 vdattach(vi)
281 register struct vba_device *vi;
282 {
283 register int unit = vi->ui_unit;
284 register struct disklabel *lp = &dklabel[unit];
285
286 /*
287 * Try to initialize device and read pack label.
288 */
289 if (vdinit(vdminor(unit, 0), 0) != 0) {
290 printf(": unknown drive type");
291 return;
292 }
293 if (dksoftc[unit].dk_state == OPEN)
294 printf(": %s <secsize %d, ntrak %d, ncyl %d, nsec %d>",
295 lp->d_typename, lp->d_secsize,
296 lp->d_ntracks, lp->d_ncylinders, lp->d_nsectors);
297 /*
298 * (60 / rpm) / (sectors per track * (bytes per sector / 2))
299 */
300 if (vi->ui_dk >= 0)
301 dk_wpms[vi->ui_dk] =
302 (lp->d_rpm * lp->d_nsectors * lp->d_secsize) / 120;
303 #ifdef notyet
304 addswap(makedev(VDMAJOR, vdminor(unit, 0)), lp);
305 #endif
306 }
307
vdopen(dev,flags,fmt)308 vdopen(dev, flags, fmt)
309 dev_t dev;
310 int flags, fmt;
311 {
312 register unit = vdunit(dev);
313 register struct disklabel *lp;
314 register struct dksoftc *dk;
315 register struct partition *pp;
316 struct vba_device *vi;
317 int s, error = 0, part = vdpart(dev), mask = 1 << part;
318 daddr_t start, end;
319
320 if (unit >= NDK || (vi = vddinfo[unit]) == 0 || vi->ui_alive == 0)
321 return (ENXIO);
322 lp = &dklabel[unit];
323 dk = &dksoftc[unit];
324
325 s = spl7();
326 while (dk->dk_state != OPEN && dk->dk_state != OPENRAW &&
327 dk->dk_state != CLOSED)
328 if (error = tsleep((caddr_t)dk, (PZERO+1) | PCATCH, devopn, 0))
329 break;
330 splx(s);
331 if (error)
332 return (error);
333 if (dk->dk_state != OPEN && dk->dk_state != OPENRAW)
334 if (error = vdinit(dev, flags))
335 return (error);
336
337 if (vdwstart == 0) {
338 timeout(vdwatch, (caddr_t)0, hz);
339 vdwstart++;
340 }
341 /*
342 * Warn if a partion is opened
343 * that overlaps another partition which is open
344 * unless one is the "raw" partition (whole disk).
345 */
346 #define RAWPART 8 /* 'x' partition */ /* XXX */
347 if ((dk->dk_openpart & mask) == 0 && part != RAWPART) {
348 pp = &lp->d_partitions[part];
349 start = pp->p_offset;
350 end = pp->p_offset + pp->p_size;
351 for (pp = lp->d_partitions;
352 pp < &lp->d_partitions[lp->d_npartitions]; pp++) {
353 if (pp->p_offset + pp->p_size <= start ||
354 pp->p_offset >= end)
355 continue;
356 if (pp - lp->d_partitions == RAWPART)
357 continue;
358 if (dk->dk_openpart & (1 << (pp - lp->d_partitions)))
359 log(LOG_WARNING,
360 "dk%d%c: overlaps open partition (%c)\n",
361 unit, part + 'a',
362 pp - lp->d_partitions + 'a');
363 }
364 }
365 if (part >= lp->d_npartitions)
366 return (ENXIO);
367 dk->dk_openpart |= mask;
368 switch (fmt) {
369 case S_IFCHR:
370 dk->dk_copenpart |= mask;
371 break;
372 case S_IFBLK:
373 dk->dk_bopenpart |= mask;
374 break;
375 }
376 return (0);
377 }
378
379 /* ARGSUSED */
vdclose(dev,flags,fmt)380 vdclose(dev, flags, fmt)
381 dev_t dev;
382 int flags, fmt;
383 {
384 register int unit = vdunit(dev);
385 register struct dksoftc *dk = &dksoftc[unit];
386 int part = vdpart(dev), mask = 1 << part;
387
388 switch (fmt) {
389 case S_IFCHR:
390 dk->dk_copenpart &= ~mask;
391 break;
392 case S_IFBLK:
393 dk->dk_bopenpart &= ~mask;
394 break;
395 }
396 if (((dk->dk_copenpart | dk->dk_bopenpart) & mask) == 0)
397 dk->dk_openpart &= ~mask;
398 /*
399 * Should wait for i/o to complete on this partition
400 * even if others are open, but wait for work on blkflush().
401 */
402 if (dk->dk_openpart == 0) {
403 int s = spl7();
404 while (dkutab[unit].b_actf)
405 sleep((caddr_t)dk, PZERO-1);
406 splx(s);
407 dk->dk_state = CLOSED;
408 dk->dk_wlabel = 0;
409 }
410 return (0);
411 }
412
vdinit(dev,flags)413 vdinit(dev, flags)
414 dev_t dev;
415 int flags;
416 {
417 register struct disklabel *lp;
418 register struct dksoftc *dk;
419 struct vba_device *vi;
420 int unit = vdunit(dev), error = 0;
421 char *msg, *readdisklabel();
422 extern int cold;
423
424 dk = &dksoftc[unit];
425 if (flags & O_NDELAY) {
426 dk->dk_state = OPENRAW;
427 return (0);
428 }
429 dk->dk_state = RDLABEL;
430 lp = &dklabel[unit];
431 vi = vddinfo[unit];
432 if (msg = readdisklabel(dev, vdstrategy, lp)) {
433 if (cold) {
434 printf(": %s", msg);
435 dk->dk_state = CLOSED;
436 } else {
437 log(LOG_ERR, "dk%d: %s\n", unit, msg);
438 dk->dk_state = OPENRAW;
439 }
440 #ifdef COMPAT_42
441 vdlock(vi->ui_ctlr);
442 if (vdmaptype(vi, lp))
443 dk->dk_state = OPEN;
444 vdunlock(vi->ui_ctlr);
445 #endif
446 } else {
447 /*
448 * Now that we have the label, configure
449 * the correct drive parameters.
450 */
451 vdlock(vi->ui_ctlr);
452 if (vdreset_drive(vi))
453 dk->dk_state = OPEN;
454 else {
455 dk->dk_state = CLOSED;
456 error = ENXIO;
457 }
458 vdunlock(vi->ui_ctlr);
459 }
460 #ifndef SECSIZE
461 vd_setsecsize(dk, lp);
462 #endif
463 wakeup((caddr_t)dk);
464 return (error);
465 }
466
467 #ifndef SECSIZE
vd_setsecsize(dk,lp)468 vd_setsecsize(dk, lp)
469 register struct dksoftc *dk;
470 register struct disklabel *lp;
471 {
472 int mul;
473
474 /*
475 * Calculate scaling shift for mapping
476 * DEV_BSIZE blocks to drive sectors.
477 */
478 mul = DEV_BSIZE / lp->d_secsize;
479 dk->dk_bshift = 0;
480 while ((mul >>= 1) > 0)
481 dk->dk_bshift++;
482 }
483 #endif SECSIZE
484
485 /*ARGSUSED*/
486 vddgo(vm)
487 struct vba_device *vm;
488 {
489
490 }
491
vdstrategy(bp)492 vdstrategy(bp)
493 register struct buf *bp;
494 {
495 register struct vba_device *vi;
496 register struct disklabel *lp;
497 register struct dksoftc *dk;
498 register int unit;
499 register daddr_t sn;
500 struct buf *dp;
501 daddr_t sz, maxsz;
502 int part, s;
503
504 unit = vdunit(bp->b_dev);
505 if (unit >= NDK) {
506 bp->b_error = ENXIO;
507 goto bad;
508 }
509 vi = vddinfo[unit];
510 lp = &dklabel[unit];
511 if (vi == 0 || vi->ui_alive == 0) {
512 bp->b_error = ENXIO;
513 goto bad;
514 }
515 dk = &dksoftc[unit];
516 if (dk->dk_state < OPEN) {
517 if (dk->dk_state == CLOSED) {
518 bp->b_error = EIO;
519 goto bad;
520 }
521 goto q;
522 }
523 if (dk->dk_state != OPEN && (bp->b_flags & B_READ) == 0) {
524 bp->b_error = EROFS;
525 goto bad;
526 }
527 part = vdpart(bp->b_dev);
528 if ((dk->dk_openpart & (1 << part)) == 0) {
529 bp->b_error = ENODEV;
530 goto bad;
531 }
532 sz = (bp->b_bcount + lp->d_secsize - 1) / lp->d_secsize;
533 maxsz = lp->d_partitions[part].p_size;
534 #ifndef SECSIZE
535 sn = bp->b_blkno << dk->dk_bshift;
536 #else SECSIZE
537 sn = bp->b_blkno;
538 #endif SECSIZE
539 if (sn + lp->d_partitions[part].p_offset <= LABELSECTOR &&
540 #if LABELSECTOR != 0
541 sn + lp->d_partitions[part].p_offset + sz > LABELSECTOR &&
542 #endif
543 (bp->b_flags & B_READ) == 0 && dk->dk_wlabel == 0) {
544 bp->b_error = EROFS;
545 goto bad;
546 }
547 if (sn < 0 || sn + sz > maxsz) {
548 if (sn == maxsz) {
549 bp->b_resid = bp->b_bcount;
550 goto done;
551 }
552 sz = maxsz - sn;
553 if (sz <= 0) {
554 bp->b_error = EINVAL;
555 goto bad;
556 }
557 bp->b_bcount = sz * lp->d_secsize;
558 }
559 bp->b_cylin = (sn + lp->d_partitions[part].p_offset) / lp->d_secpercyl;
560 #ifdef SECSIZE
561 if (bp->b_blksize != lp->d_secsize && (bp->b_flags & B_PGIN) == 0)
562 panic("vdstrat blksize");
563 #endif SECSIZE
564 q:
565 s = spl7();
566 dp = &dkutab[vi->ui_unit];
567 disksort(dp, bp);
568 if (!dp->b_active) {
569 (void) vdustart(vi);
570 if (!vi->ui_mi->um_tab.b_active)
571 vdstart(vi->ui_mi);
572 }
573 splx(s);
574 return;
575 bad:
576 bp->b_flags |= B_ERROR;
577 done:
578 biodone(bp);
579 return;
580 }
581
vdustart(vi)582 vdustart(vi)
583 register struct vba_device *vi;
584 {
585 register struct buf *bp, *dp;
586 register struct vba_ctlr *vm;
587 register int unit = vi->ui_unit;
588 register struct dksoftc *dk;
589 register struct vdsoftc *vd;
590 struct disklabel *lp;
591
592 dp = &dkutab[unit];
593 /*
594 * If queue empty, nothing to do.
595 */
596 if ((bp = dp->b_actf) == NULL)
597 return;
598 /*
599 * If drive is off-cylinder and controller supports seeks,
600 * place drive on seek queue for controller.
601 * Otherwise, place on transfer queue.
602 */
603 vd = &vdsoftc[vi->ui_ctlr];
604 dk = &dksoftc[unit];
605 vm = vi->ui_mi;
606 if (bp->b_cylin != dk->dk_curcyl && vd->vd_flags&VD_DOSEEKS) {
607 lp = &dklabel[unit];
608 bp->b_track = (bp->b_blkno % lp->d_secpercyl) / lp->d_nsectors;
609 if (vm->um_tab.b_seekf == NULL)
610 vm->um_tab.b_seekf = dp;
611 else
612 vm->um_tab.b_seekl->b_forw = dp;
613 vm->um_tab.b_seekl = dp;
614 } else {
615 if (vm->um_tab.b_actf == NULL)
616 vm->um_tab.b_actf = dp;
617 else
618 vm->um_tab.b_actl->b_forw = dp;
619 vm->um_tab.b_actl = dp;
620 }
621 dp->b_forw = NULL;
622 dp->b_active++;
623 }
624
625 /*
626 * Start next transfer on a controller.
627 * There are two queues of drives, the first on-cylinder
628 * and the second off-cylinder from their next transfers.
629 * Perform the first transfer for the first drive on the on-cylinder
630 * queue, if any, otherwise the first transfer for the first drive
631 * on the second queue. Initiate seeks on remaining drives on the
632 * off-cylinder queue, then move them all to the on-cylinder queue.
633 */
vdstart(vm)634 vdstart(vm)
635 register struct vba_ctlr *vm;
636 {
637 register struct buf *bp;
638 register struct vba_device *vi;
639 register struct vdsoftc *vd;
640 register struct dksoftc *dk;
641 register struct disklabel *lp;
642 register struct dcb **dcbp;
643 struct buf *dp;
644 int sn, tn;
645
646 loop:
647 /*
648 * Pull a request off the controller queue.
649 */
650 if ((dp = vm->um_tab.b_actf) == NULL &&
651 (dp = vm->um_tab.b_seekf) == NULL)
652 return;
653 if ((bp = dp->b_actf) == NULL) {
654 if (dp == vm->um_tab.b_actf)
655 vm->um_tab.b_actf = dp->b_forw;
656 else
657 vm->um_tab.b_seekf = dp->b_forw;
658 goto loop;
659 }
660
661 /*
662 * Mark controller busy, and determine
663 * destination of this request.
664 */
665 vm->um_tab.b_active++;
666 vi = vddinfo[vdunit(bp->b_dev)];
667 dk = &dksoftc[vi->ui_unit];
668 #ifndef SECSIZE
669 sn = bp->b_blkno << dk->dk_bshift;
670 #else SECSIZE
671 sn = bp->b_blkno;
672 #endif SECSIZE
673 lp = &dklabel[vi->ui_unit];
674 sn %= lp->d_secpercyl;
675 tn = sn / lp->d_nsectors;
676 sn %= lp->d_nsectors;
677
678 /*
679 * Construct dcb for read/write command.
680 */
681 vd = &vdsoftc[vm->um_ctlr];
682 vd->vd_dcb.intflg = DCBINT_DONE;
683 vd->vd_dcb.devselect = dk->dk_dcb.devselect;
684 vd->vd_dcb.operrsta = 0;
685 vd->vd_dcb.nxtdcb = (struct dcb *)0; /* end of chain */
686 vd->vd_dcb.trail.rwtrail.disk.cylinder = bp->b_cylin;
687 vd->vd_dcb.trail.rwtrail.disk.track = tn;
688 vd->vd_dcb.trail.rwtrail.disk.sector = sn;
689 dk->dk_curcyl = bp->b_cylin;
690 bp->b_track = 0; /* init overloaded field */
691 vd->vd_dcb.trailcnt = sizeof (struct trrw) / sizeof (long);
692 if (bp->b_flags & B_FORMAT)
693 vd->vd_dcb.opcode = dk->dk_op;
694 else if (vd->vd_flags & VD_SCATGATH &&
695 ((int)bp->b_un.b_addr & (sizeof(long) - 1)) == 0)
696 vd->vd_dcb.opcode = (bp->b_flags & B_READ)? VDOP_RAS : VDOP_GAW;
697 else
698 vd->vd_dcb.opcode = (bp->b_flags & B_READ)? VDOP_RD : VDOP_WD;
699
700 switch (vd->vd_dcb.opcode) {
701 case VDOP_FSECT:
702 vd->vd_dcb.trailcnt = sizeof (struct trfmt) / sizeof (long);
703 vd->vd_dcb.trail.fmtrail.nsectors = bp->b_bcount /
704 lp->d_secsize;
705 vd->vd_dcb.trail.fmtrail.hdr = *(dskadr *)&dk->dk_althdr;
706 vd->vd_dcb.trail.rwtrail.disk.cylinder |= dk->dk_fmtflags;
707 goto setupaddr;
708
709 case VDOP_RDRAW:
710 case VDOP_RD:
711 case VDOP_RHDE:
712 case VDOP_WD:
713 vd->vd_dcb.trail.rwtrail.wcount = (bp->b_bcount+1) >> 1;
714 setupaddr:
715 vd->vd_dcb.trail.rwtrail.memadr =
716 vbasetup(bp, &vd->vd_rbuf, (int)lp->d_secsize);
717 break;
718
719 case VDOP_RAS:
720 case VDOP_GAW:
721 vd->vd_dcb.trailcnt += vd_sgsetup(bp, &vd->vd_rbuf,
722 &vd->vd_dcb.trail.sgtrail);
723 break;
724 }
725 if (vi->ui_dk >= 0) {
726 dk_busy |= 1<<vi->ui_dk;
727 dk_xfer[vi->ui_dk]++;
728 dk_wds[vi->ui_dk] += bp->b_bcount>>6;
729 }
730
731 /*
732 * Look for any seeks to be performed on other drives on this
733 * controller. If overlapped seeks exist, insert seek commands
734 * on the controller's command queue before the transfer.
735 */
736 dcbp = &vd->vd_mdcb.mdcb_head;
737
738 if (dp == vm->um_tab.b_seekf)
739 dp = dp->b_forw;
740 else
741 dp = vm->um_tab.b_seekf;
742 for (; dp != NULL; dp = dp->b_forw) {
743 if ((bp = dp->b_actf) == NULL)
744 continue;
745 vi = vddinfo[vdunit(bp->b_dev)];
746 dk = &dksoftc[vi->ui_unit];
747 dk->dk_curcyl = bp->b_cylin;
748 if (vi->ui_dk >= 0)
749 dk_seek[vi->ui_dk]++;
750 dk->dk_dcb.operrsta = 0;
751 dk->dk_dcb.trail.sktrail.skaddr.cylinder = bp->b_cylin;
752 dk->dk_dcb.trail.sktrail.skaddr.track = bp->b_track;
753 *dcbp = (struct dcb *)dk->dk_dcbphys;
754 dcbp = &dk->dk_dcb.nxtdcb;
755 }
756 *dcbp = (struct dcb *)vd->vd_dcbphys;
757 if (vm->um_tab.b_actf)
758 vm->um_tab.b_actl->b_forw = vm->um_tab.b_seekf;
759 else
760 vm->um_tab.b_actf = vm->um_tab.b_seekf;
761 if (vm->um_tab.b_seekf)
762 vm->um_tab.b_actl = vm->um_tab.b_seekl;
763 vm->um_tab.b_seekf = 0;
764
765 /*
766 * Initiate operation.
767 */
768 vd->vd_mdcb.mdcb_status = 0;
769 VDGO(vm->um_addr, vd->vd_mdcbphys, vd->vd_type);
770 }
771
772 /*
773 * Wait for controller to finish current operation
774 * so that direct controller accesses can be done.
775 */
vdlock(ctlr)776 vdlock(ctlr)
777 {
778 register struct vba_ctlr *vm = vdminfo[ctlr];
779 register struct vdsoftc *vd = &vdsoftc[ctlr];
780 int s;
781
782 s = spl7();
783 while (vm->um_tab.b_active || vd->vd_flags & VD_LOCKED) {
784 vd->vd_flags |= VD_WAIT;
785 sleep((caddr_t)vd, PRIBIO);
786 }
787 vd->vd_flags |= VD_LOCKED;
788 splx(s);
789 }
790
791 /*
792 * Continue normal operations after pausing for
793 * munging the controller directly.
794 */
vdunlock(ctlr)795 vdunlock(ctlr)
796 {
797 register struct vba_ctlr *vm = vdminfo[ctlr];
798 register struct vdsoftc *vd = &vdsoftc[ctlr];
799
800 vd->vd_flags &= ~VD_LOCKED;
801 if (vd->vd_flags & VD_WAIT) {
802 vd->vd_flags &= ~VD_WAIT;
803 wakeup((caddr_t)vd);
804 } else if (vm->um_tab.b_actf || vm->um_tab.b_seekf)
805 vdstart(vm);
806 }
807
808 #define DONTCARE (DCBS_DSE|DCBS_DSL|DCBS_TOP|DCBS_TOM|DCBS_FAIL|DCBS_DONE)
809 /*
810 * Handle a disk interrupt.
811 */
vdintr(ctlr)812 vdintr(ctlr)
813 register ctlr;
814 {
815 register struct buf *bp, *dp;
816 register struct vba_ctlr *vm = vdminfo[ctlr];
817 register struct vba_device *vi;
818 register struct vdsoftc *vd = &vdsoftc[ctlr];
819 register status;
820 int timedout;
821 struct dksoftc *dk;
822
823 if (!vm->um_tab.b_active) {
824 printf("vd%d: stray interrupt\n", ctlr);
825 return;
826 }
827 /*
828 * Get device and block structures, and a pointer
829 * to the vba_device for the drive.
830 */
831 dp = vm->um_tab.b_actf;
832 bp = dp->b_actf;
833 vi = vddinfo[vdunit(bp->b_dev)];
834 dk = &dksoftc[vi->ui_unit];
835 if (vi->ui_dk >= 0)
836 dk_busy &= ~(1<<vi->ui_dk);
837 timedout = (vd->vd_wticks >= VDMAXTIME);
838 /*
839 * Check for and process errors on
840 * either the drive or the controller.
841 */
842 uncache(&vd->vd_dcb.operrsta);
843 status = vd->vd_dcb.operrsta;
844 if (bp->b_flags & B_FORMAT) {
845 dk->dk_operrsta = status;
846 uncache(&vd->vd_dcb.err_code);
847 /* ecodecnt gets err_code + err_wcnt from the same longword */
848 dk->dk_ecodecnt = *(long *)&vd->vd_dcb.err_code;
849 uncache(&vd->vd_dcb.err_trk);
850 /* erraddr gets error trk/sec/cyl from the same longword */
851 dk->dk_erraddr = *(long *)&vd->vd_dcb.err_trk;
852 } else if (status & VDERR_HARD || timedout) {
853 if (vd->vd_type == VDTYPE_SMDE)
854 uncache(&vd->vd_dcb.err_code);
855 if (status & DCBS_WPT) {
856 /*
857 * Give up on write locked devices immediately.
858 */
859 printf("dk%d: write locked\n", vi->ui_unit);
860 bp->b_flags |= B_ERROR;
861 } else if (status & VDERR_RETRY || timedout) {
862 if (status & VDERR_CTLR || timedout) {
863 vdharderr(timedout ?
864 "controller timeout" : "controller err",
865 vd, bp, &vd->vd_dcb);
866 printf("; resetting controller...");
867 vdreset_ctlr(vm);
868 } else if (status & VDERR_DRIVE) {
869 vdharderr("drive err", vd, bp, &vd->vd_dcb);
870 printf("; resetting drive...");
871 if (!vdreset_drive(vi))
872 dk->dk_state = CLOSED;
873 } else
874 vdharderr("data err", vd, bp, &vd->vd_dcb);
875 /*
876 * Retry transfer once, unless reset failed.
877 */
878 if (!vi->ui_alive || dp->b_errcnt++ >= 1) {
879 printf("\n");
880 goto hard;
881 }
882
883 printf(" retrying\n");
884 vm->um_tab.b_active = 0; /* force retry */
885 } else {
886 vdharderr("hard error", vd, bp, &vd->vd_dcb);
887 printf("\n");
888 hard:
889 bp->b_flags |= B_ERROR;
890 }
891 } else if (status & DCBS_SOFT)
892 vdsofterr(bp, &vd->vd_dcb);
893 if (vd->vd_wticks > 3) {
894 vd->vd_dcb.err_code = vd->vd_wticks;
895 vdharderr("slow transfer (ecode is sec.)", vd, bp, &vd->vd_dcb);
896 printf("\n");
897 }
898 vd->vd_wticks = 0;
899 if (vm->um_tab.b_active) {
900 vm->um_tab.b_active = 0;
901 vm->um_tab.b_actf = dp->b_forw;
902 dp->b_active = 0;
903 dp->b_errcnt = 0;
904 dp->b_actf = bp->av_forw;
905 bp->b_resid = 0;
906 vbadone(bp, &vd->vd_rbuf);
907 biodone(bp);
908 /*
909 * If this unit has more work to do,
910 * then start it up right away.
911 */
912 if (dp->b_actf)
913 vdustart(vi);
914 else if (dk->dk_openpart == 0)
915 wakeup((caddr_t)dk);
916 }
917 /*
918 * If there are devices ready to
919 * transfer, start the controller.
920 */
921 if (vd->vd_flags & VD_WAIT) {
922 vd->vd_flags &= ~VD_WAIT;
923 wakeup((caddr_t)vd);
924 } else if (vm->um_tab.b_actf || vm->um_tab.b_seekf)
925 vdstart(vm);
926 }
927
vdharderr(what,vd,bp,dcb)928 vdharderr(what, vd, bp, dcb)
929 char *what;
930 struct vdsoftc *vd;
931 register struct buf *bp;
932 register struct dcb *dcb;
933 {
934 int unit = vdunit(bp->b_dev), status = dcb->operrsta;
935 register struct disklabel *lp = &dklabel[unit];
936 int blkdone;
937
938 if (vd->vd_wticks < VDMAXTIME)
939 status &= ~DONTCARE;
940 blkdone = ((((dcb->err_cyl & 0xfff) * lp->d_ntracks + dcb->err_trk) *
941 lp->d_nsectors + dcb->err_sec -
942 lp->d_partitions[vdpart(bp->b_dev)].p_offset) >>
943 dksoftc[unit].dk_bshift) - bp->b_blkno;
944 diskerr(bp, "dk", what, LOG_PRINTF, blkdone, lp);
945 printf(", status %b", status, VDERRBITS);
946 if (vd->vd_type == VDTYPE_SMDE)
947 printf(" ecode %x", dcb->err_code);
948 }
949
vdsofterr(bp,dcb)950 vdsofterr(bp, dcb)
951 register struct buf *bp;
952 register struct dcb *dcb;
953 {
954 int unit = vdunit(bp->b_dev);
955 struct disklabel *lp = &dklabel[unit];
956 int status = dcb->operrsta;
957 int blkdone;
958
959 blkdone = ((((dcb->err_cyl & 0xfff) * lp->d_ntracks + dcb->err_trk) *
960 lp->d_nsectors + dcb->err_sec -
961 lp->d_partitions[vdpart(bp->b_dev)].p_offset) >>
962 dksoftc[unit].dk_bshift) - bp->b_blkno;
963
964 if (status != (DCBS_CCD|DCBS_SOFT|DCBS_ERR|DCBS_DONE)) {
965 diskerr(bp, "dk", "soft error", LOG_WARNING, blkdone, lp);
966 addlog(", status %b ecode %x\n", status, VDERRBITS,
967 dcb->err_code);
968 } else {
969 diskerr(bp, "dk", "soft ecc", LOG_WARNING, blkdone, lp);
970 addlog("\n");
971 }
972 }
973
vdioctl(dev,cmd,data,flag)974 vdioctl(dev, cmd, data, flag)
975 dev_t dev;
976 int cmd;
977 caddr_t data;
978 int flag;
979 {
980 register int unit = vdunit(dev);
981 register struct disklabel *lp = &dklabel[unit];
982 register struct dksoftc *dk = &dksoftc[unit];
983 int error = 0, vdformat();
984
985 switch (cmd) {
986
987 case DIOCGDINFO:
988 *(struct disklabel *)data = *lp;
989 break;
990
991 case DIOCGPART:
992 ((struct partinfo *)data)->disklab = lp;
993 ((struct partinfo *)data)->part =
994 &lp->d_partitions[vdpart(dev)];
995 break;
996
997 case DIOCSDINFO:
998 if ((flag & FWRITE) == 0)
999 error = EBADF;
1000 else
1001 error = setdisklabel(lp, (struct disklabel *)data,
1002 (dk->dk_state == OPENRAW) ? 0 : dk->dk_openpart);
1003 if (error == 0 && dk->dk_state == OPENRAW &&
1004 vdreset_drive(vddinfo[unit]))
1005 dk->dk_state = OPEN;
1006 break;
1007
1008 case DIOCWLABEL:
1009 if ((flag & FWRITE) == 0)
1010 error = EBADF;
1011 else
1012 dk->dk_wlabel = *(int *)data;
1013 break;
1014
1015 case DIOCWDINFO:
1016 if ((flag & FWRITE) == 0)
1017 error = EBADF;
1018 else if ((error = setdisklabel(lp, (struct disklabel *)data,
1019 (dk->dk_state == OPENRAW) ? 0 : dk->dk_openpart)) == 0) {
1020 int wlab;
1021
1022 if (error == 0 && dk->dk_state == OPENRAW &&
1023 vdreset_drive(vddinfo[unit]))
1024 dk->dk_state = OPEN;
1025 /* simulate opening partition 0 so write succeeds */
1026 dk->dk_openpart |= (1 << 0); /* XXX */
1027 wlab = dk->dk_wlabel;
1028 dk->dk_wlabel = 1;
1029 error = writedisklabel(dev, vdstrategy, lp);
1030 dk->dk_openpart = dk->dk_copenpart | dk->dk_bopenpart;
1031 dk->dk_wlabel = wlab;
1032 }
1033 break;
1034
1035 case DIOCWFORMAT:
1036 {
1037 register struct format_op *fop;
1038 struct uio auio;
1039 struct iovec aiov;
1040
1041 if ((flag & FWRITE) == 0) {
1042 error = EBADF;
1043 break;
1044 }
1045 fop = (struct format_op *)data;
1046 aiov.iov_base = fop->df_buf;
1047 aiov.iov_len = fop->df_count;
1048 auio.uio_iov = &aiov;
1049 auio.uio_iovcnt = 1;
1050 auio.uio_resid = fop->df_count;
1051 auio.uio_segflg = UIO_USERSPACE;
1052 auio.uio_offset = fop->df_startblk * lp->d_secsize;
1053 /* This assumes one active format operation per disk... */
1054 dk->dk_op = fop->dk_op;
1055 dk->dk_althdr = fop->dk_althdr;
1056 dk->dk_fmtflags = fop->dk_fmtflags;
1057 /*
1058 * Don't return errors, as the format op won't get copied
1059 * out if we return nonzero. Callers must check the returned
1060 * registers and count.
1061 */
1062 error = physio(vdformat, (struct buf *)NULL, dev,
1063 B_WRITE, minphys, &auio);
1064 if (error == EIO)
1065 error = 0;
1066 fop->df_count -= auio.uio_resid;
1067 /* This assumes one active format operation per disk... */
1068 fop->dk_operrsta = dk->dk_operrsta;
1069 fop->dk_ecodecnt = dk->dk_ecodecnt;
1070 fop->dk_erraddr = dk->dk_erraddr;
1071 break;
1072 }
1073
1074 default:
1075 error = ENOTTY;
1076 break;
1077 }
1078 return (error);
1079 }
1080
1081 vdformat(bp)
1082 struct buf *bp;
1083 {
1084 bp->b_flags |= B_FORMAT;
1085 vdstrategy(bp);
1086 }
1087
1088 /*
1089 * Watch for lost interrupts.
1090 */
vdwatch()1091 vdwatch()
1092 {
1093 register struct vdsoftc *vd;
1094 register struct vba_ctlr *vm;
1095 register int ctlr;
1096 int s;
1097
1098 timeout(vdwatch, (caddr_t)0, hz);
1099 for (ctlr = 0; ctlr < NVD; ctlr++) {
1100 vm = vdminfo[ctlr];
1101 if (vm == 0 || vm->um_alive == 0)
1102 continue;
1103 vd = &vdsoftc[ctlr];
1104 s = spl7();
1105 if (vm->um_tab.b_active && vd->vd_wticks++ >= VDMAXTIME) {
1106 printf("vd%d: lost interrupt\n", ctlr);
1107 #ifdef maybe
1108 VDABORT((struct vddevice *)vm->um_addr, vd->vd_type);
1109 #endif
1110 vdintr(ctlr);
1111 }
1112 splx(s);
1113 }
1114 }
1115
1116 #define DBSIZE 64 /* controller limit with 1K sectors */
1117 /*
1118 * Crash dump.
1119 */
vddump(dev)1120 vddump(dev)
1121 dev_t dev;
1122 {
1123 register struct vba_device *vi;
1124 register struct vba_ctlr *vm;
1125 register struct disklabel *lp;
1126 register struct vdsoftc *vd;
1127 struct dksoftc *dk;
1128 int part, unit, num;
1129 u_long start;
1130
1131 start = 0;
1132 unit = vdunit(dev);
1133 if (unit > NDK || (vi = vddinfo[unit]) == 0 || vi->ui_alive == 0)
1134 return (ENXIO);
1135 dk = &dksoftc[unit];
1136 if (dk->dk_state != OPEN && dk->dk_state != OPENRAW &&
1137 vdinit(vdminor(unit, 0), 0) != 0)
1138 return (ENXIO);
1139 lp = &dklabel[unit];
1140 part = vdpart(dev);
1141 if (part >= lp->d_npartitions)
1142 return (ENXIO);
1143 vm = vi->ui_mi;
1144 vdreset_ctlr(vm);
1145 if (dumplo < 0)
1146 return (EINVAL);
1147 /*
1148 * Maxfree is in pages, dumplo is in DEV_BSIZE units.
1149 */
1150 num = maxfree * (NBPG / lp->d_secsize);
1151 dumplo *= DEV_BSIZE / lp->d_secsize;
1152 if (dumplo + num >= lp->d_partitions[vdpart(dev)].p_size)
1153 num = lp->d_partitions[vdpart(dev)].p_size - dumplo;
1154 vd = &vdsoftc[vm->um_ctlr];
1155 vd->vd_dcb.intflg = DCBINT_NONE;
1156 vd->vd_dcb.opcode = VDOP_WD;
1157 vd->vd_dcb.devselect = dk->dk_dcb.devselect;
1158 vd->vd_dcb.trailcnt = sizeof (struct trrw) / sizeof (long);
1159 while (num > 0) {
1160 int nsec, cn, sn, tn;
1161
1162 nsec = MIN(num, DBSIZE);
1163 sn = dumplo + start / lp->d_secsize;
1164 cn = (sn + lp->d_partitions[vdpart(dev)].p_offset) /
1165 lp->d_secpercyl;
1166 sn %= lp->d_secpercyl;
1167 tn = sn / lp->d_nsectors;
1168 sn %= lp->d_nsectors;
1169 vd->vd_mdcb.mdcb_head = (struct dcb *)vd->vd_dcbphys;
1170 vd->vd_dcb.trail.rwtrail.memadr = start;
1171 vd->vd_dcb.trail.rwtrail.wcount = (nsec * lp->d_secsize) >> 1;
1172 vd->vd_dcb.trail.rwtrail.disk.cylinder = cn;
1173 vd->vd_dcb.trail.rwtrail.disk.track = tn;
1174 vd->vd_dcb.trail.rwtrail.disk.sector = sn;
1175 vd->vd_dcb.operrsta = 0;
1176 VDGO(vm->um_addr, vd->vd_mdcbphys, vd->vd_type);
1177 if (!vdpoll(vm, 5)) {
1178 printf(" during dump\n");
1179 return (EIO);
1180 }
1181 if (vd->vd_dcb.operrsta & VDERR_HARD) {
1182 printf("dk%d: hard error, status=%b\n", unit,
1183 vd->vd_dcb.operrsta, VDERRBITS);
1184 return (EIO);
1185 }
1186 start += nsec * lp->d_secsize;
1187 num -= nsec;
1188 }
1189 return (0);
1190 }
1191
vdsize(dev)1192 vdsize(dev)
1193 dev_t dev;
1194 {
1195 register int unit = vdunit(dev);
1196 register struct dksoftc *dk;
1197 struct vba_device *vi;
1198 struct disklabel *lp;
1199
1200 if (unit >= NDK || (vi = vddinfo[unit]) == 0 || vi->ui_alive == 0 ||
1201 (dk = &dksoftc[unit])->dk_state != OPEN)
1202 return (-1);
1203 lp = &dklabel[unit];
1204 #ifdef SECSIZE
1205 return ((int)lp->d_partitions[vdpart(dev)].p_size);
1206 #else SECSIZE
1207 return ((int)lp->d_partitions[vdpart(dev)].p_size >> dk->dk_bshift);
1208 #endif SECSIZE
1209 }
1210
1211 /*
1212 * Initialize controller.
1213 */
1214 vdinit_ctlr(vm, vd)
1215 struct vba_ctlr *vm;
1216 struct vdsoftc *vd;
1217 {
1218 register struct vddevice *vdaddr = (struct vddevice *)vm->um_addr;
1219
1220 if (vd->vd_type == VDTYPE_SMDE) {
1221 vdaddr->vdcsr = 0;
1222 vdaddr->vdtcf_mdcb = AM_ENPDA;
1223 vdaddr->vdtcf_dcb = AM_ENPDA;
1224 vdaddr->vdtcf_trail = AM_ENPDA;
1225 vdaddr->vdtcf_data = AM_ENPDA;
1226 vdaddr->vdccf = CCF_SEN | CCF_DIU | CCF_STS | CCF_RFE |
1227 XMD_32BIT | BSZ_16WRD |
1228 CCF_ENP | CCF_EPE | CCF_EDE | CCF_ECE | CCF_ERR;
1229 }
1230 if (!vdcmd(vm, VDOP_INIT, 10, 0) || !vdcmd(vm, VDOP_DIAG, 10, 0)) {
1231 printf("vd%d: %s cmd failed\n", vm->um_ctlr,
1232 vd->vd_dcb.opcode == VDOP_INIT ? "init" : "diag");
1233 return (0);
1234 }
1235 vd->vd_secsize = vdaddr->vdsecsize << 1;
1236 return (1);
1237 }
1238
1239 /*
1240 * Perform a controller reset.
1241 */
vdreset_ctlr(vm)1242 vdreset_ctlr(vm)
1243 register struct vba_ctlr *vm;
1244 {
1245 register struct vddevice *vdaddr = (struct vddevice *)vm->um_addr;
1246 register struct vdsoftc *vd = &vdsoftc[vm->um_ctlr];
1247 register int unit;
1248 struct vba_device *vi;
1249
1250 VDRESET(vdaddr, vd->vd_type);
1251 if (vdinit_ctlr(vm, vd) == 0)
1252 return;
1253 for (unit = 0; unit < NDK; unit++)
1254 if ((vi = vddinfo[unit]) && vi->ui_mi == vm && vi->ui_alive)
1255 (void) vdreset_drive(vi);
1256 }
1257
vdreset_drive(vi)1258 vdreset_drive(vi)
1259 register struct vba_device *vi;
1260 {
1261 register struct disklabel *lp = &dklabel[vi->ui_unit];
1262 struct vba_ctlr *vm = vdminfo[vi->ui_ctlr];
1263 struct vddevice *vdaddr = (struct vddevice *)vm->um_addr;
1264 register struct vdsoftc *vd = &vdsoftc[vi->ui_ctlr];
1265 register struct dksoftc *dk = &dksoftc[vi->ui_unit];
1266 int config_status, config_ecode, saw_drive = 0;
1267
1268 #ifdef notdef
1269 /*
1270 * check for ESDI distribution panel already configured,
1271 * e.g. on boot drive, or if PROBE on controller actually
1272 * worked. Status will be zero if drive hasn't
1273 * been probed yet.
1274 */
1275 #if STA_ESDI != 0
1276 if ((vdaddr->vdstatus[vi->ui_slave] & STA_TYPE) == STA_ESDI)
1277 lp->d_devflags |= VD_ESDI;
1278 #endif
1279 #endif
1280 top:
1281 vd->vd_dcb.opcode = VDOP_CONFIG; /* command */
1282 vd->vd_dcb.intflg = DCBINT_NONE;
1283 vd->vd_dcb.nxtdcb = (struct dcb *)0; /* end of chain */
1284 vd->vd_dcb.operrsta = 0;
1285 vd->vd_dcb.devselect = vi->ui_slave | lp->d_devflags;
1286 vd->vd_dcb.trail.rstrail.ncyl = lp->d_ncylinders;
1287 vd->vd_dcb.trail.rstrail.nsurfaces = lp->d_ntracks;
1288 if (vd->vd_type == VDTYPE_SMDE) {
1289 vd->vd_dcb.trailcnt = sizeof (struct treset) / sizeof (long);
1290 vd->vd_dcb.trail.rstrail.nsectors = lp->d_nsectors;
1291 vd->vd_dcb.trail.rstrail.slip_sec = lp->d_sparespertrack;
1292 vd->vd_dcb.trail.rstrail.recovery =
1293 (lp->d_flags & D_REMOVABLE) ? VDRF_NORMAL :
1294 (VDRF_NORMAL &~ (VDRF_OSP|VDRF_OSM));
1295 } else
1296 vd->vd_dcb.trailcnt = 2; /* XXX */
1297 vd->vd_mdcb.mdcb_head = (struct dcb *)vd->vd_dcbphys;
1298 vd->vd_mdcb.mdcb_status = 0;
1299 VDGO(vdaddr, vd->vd_mdcbphys, vd->vd_type);
1300 if (!vdpoll(vm, 5)) {
1301 printf(" during config\n");
1302 return (0);
1303 }
1304 config_status = vd->vd_dcb.operrsta;
1305 config_ecode = (u_char)vd->vd_dcb.err_code;
1306 if (config_status & VDERR_HARD) {
1307 if (vd->vd_type == VDTYPE_SMDE) {
1308 /*
1309 * If drive status was updated successfully,
1310 * STA_US (unit selected) should be set
1311 * if the drive is attached and powered up.
1312 * (But only if we've guessed right on SMD
1313 * vs. ESDI; if that flag is wrong, we won't
1314 * see the drive.) If we don't see STA_US
1315 * with either SMD or ESDI set for the unit,
1316 * we assume that the drive doesn't exist,
1317 * and don't wait for it to spin up.
1318 */
1319 (void) vdcmd(vm, VDOP_STATUS, 5, vi->ui_slave);
1320 uncache(&vdaddr->vdstatus[vi->ui_slave]);
1321 if (vdaddr->vdstatus[vi->ui_slave] & STA_US)
1322 saw_drive = 1;
1323 else if (lp->d_devflags == 0) {
1324 lp->d_devflags = VD_ESDI;
1325 goto top;
1326 }
1327 } else
1328 saw_drive = 1;
1329 if ((config_status & (DCBS_OCYL|DCBS_NRDY)) == 0)
1330 printf("dk%d: config error %b ecode %x\n", vi->ui_unit,
1331 config_status, VDERRBITS, config_ecode);
1332 else if ((vd->vd_flags & VD_STARTED) == 0 && saw_drive) {
1333 int started;
1334
1335 printf(" starting drives, wait ... ");
1336 vd->vd_flags |= VD_STARTED;
1337 started = (vdcmd(vm, VDOP_START, 10) == 1);
1338 DELAY(62000000);
1339 printf("done\n");
1340 lp->d_devflags = 0;
1341 if (started)
1342 goto top;
1343 }
1344 return (0);
1345 }
1346 dk->dk_dcb.devselect |= lp->d_devflags;
1347 return (1);
1348 }
1349
1350 /*
1351 * Perform a command w/o trailer.
1352 */
vdcmd(vm,cmd,t,slave)1353 vdcmd(vm, cmd, t, slave)
1354 register struct vba_ctlr *vm;
1355 {
1356 register struct vdsoftc *vd = &vdsoftc[vm->um_ctlr];
1357
1358 vd->vd_dcb.opcode = cmd; /* command */
1359 vd->vd_dcb.intflg = DCBINT_NONE;
1360 vd->vd_dcb.nxtdcb = (struct dcb *)0; /* end of chain */
1361 vd->vd_dcb.operrsta = 0;
1362 vd->vd_dcb.devselect = slave;
1363 vd->vd_dcb.trailcnt = 0;
1364 vd->vd_mdcb.mdcb_head = (struct dcb *)vd->vd_dcbphys;
1365 vd->vd_mdcb.mdcb_status = 0;
1366 VDGO(vm->um_addr, vd->vd_mdcbphys, vd->vd_type);
1367 if (!vdpoll(vm, t)) {
1368 printf(" during init\n");
1369 return (0);
1370 }
1371 return ((vd->vd_dcb.operrsta&VDERR_HARD) == 0);
1372 }
1373
1374 /*
1375 * Poll controller until operation
1376 * completes or timeout expires.
1377 */
vdpoll(vm,t)1378 vdpoll(vm, t)
1379 register struct vba_ctlr *vm;
1380 register int t;
1381 {
1382 register struct vdsoftc *vd = &vdsoftc[vm->um_ctlr];
1383 register struct vddevice *vdaddr = (struct vddevice *)vm->um_addr;
1384
1385 t *= 1000;
1386 for (;;) {
1387 uncache(&vd->vd_dcb.operrsta);
1388 if (vd->vd_dcb.operrsta & (DCBS_DONE|DCBS_ABORT))
1389 break;
1390 if (--t <= 0) {
1391 printf("vd%d: controller timeout", vm->um_ctlr);
1392 VDABORT(vdaddr, vd->vd_type);
1393 return (0);
1394 }
1395 DELAY(1000);
1396 }
1397 if (vd->vd_type == VDTYPE_SMDE) {
1398 do {
1399 DELAY(50);
1400 uncache(&vdaddr->vdcsr);
1401 } while (vdaddr->vdcsr & CS_GO);
1402 DELAY(300);
1403 uncache(&vd->vd_dcb.err_code);
1404 }
1405 DELAY(200);
1406 uncache(&vd->vd_dcb.operrsta);
1407 return (1);
1408 }
1409
1410 #ifdef COMPAT_42
1411 struct vdst {
1412 int nsec; /* sectors/track */
1413 int ntrack; /* tracks/cylinder */
1414 int ncyl; /* cylinders */
1415 int secsize; /* sector size */
1416 char *name; /* type name */
1417 struct {
1418 int off; /* partition offset in sectors */
1419 int size; /* partition size in sectors */
1420 } parts[8];
1421 } vdst[] = {
1422 { 66, 23, 850, 512, "NEC 800",
1423 {0, 1290300}, /* a cyl 0 - 849 */
1424 },
1425 { 64, 20, 842, 512, "2361a",
1426 {0, 61440}, /* a cyl 0 - 47 */
1427 {61440, 67840}, /* b cyl 48 - 100 */
1428 {129280, 942080}, /* c cyl 101 - 836 */
1429 {0, 1071360}, /* d cyl 0 - 836 */
1430 {449280, 311040}, /* e cyl 351 - 593 */
1431 {760320, 311040}, /* f cyl 594 - 836 */
1432 {449280, 622080}, /* g cyl 351 - 836 */
1433 {129280, 320000} /* h cyl 101 - 350 */
1434 },
1435 { 48, 24, 711, 512, "xsd",
1436 {0, 61056}, /* a cyl 0 - 52 */
1437 {61056, 61056}, /* b cyl 53 - 105 */
1438 {122112, 691200}, /* c cyl 106 - 705 */
1439 {237312, 576000}, /* d cyl 206 - 705 */
1440 {352512, 460800}, /* e cyl 306 - 705 */
1441 {467712, 345600}, /* f cyl 406 - 705 */
1442 {582912, 230400}, /* g cyl 506 - 705 */
1443 {698112, 115200} /* h cyl 606 - 705 */
1444 },
1445 { 44, 20, 842, 512, "eagle",
1446 {0, 52800}, /* egl0a cyl 0 - 59 */
1447 {52800, 66000}, /* egl0b cyl 60 - 134 */
1448 {118800, 617760}, /* egl0c cyl 135 - 836 */
1449 {736560, 4400}, /* egl0d cyl 837 - 841 */
1450 {0, 736560}, /* egl0e cyl 0 - 836 */
1451 {0, 740960}, /* egl0f cyl 0 - 841 */
1452 {118800, 310640}, /* egl0g cyl 135 - 487 */
1453 {429440, 307120} /* egl0h cyl 488 - 836 */
1454 },
1455 { 64, 10, 823, 512, "fuj",
1456 {0, 38400}, /* fuj0a cyl 0 - 59 */
1457 {38400, 48000}, /* fuj0b cyl 60 - 134 */
1458 {86400, 437120}, /* fuj0c cyl 135 - 817 */
1459 {159360, 364160}, /* fuj0d cyl 249 - 817 */
1460 {232320, 291200}, /* fuj0e cyl 363 - 817 */
1461 {305280, 218240}, /* fuj0f cyl 477 - 817 */
1462 {378240, 145280}, /* fuj0g cyl 591 - 817 */
1463 {451200, 72320} /* fug0h cyl 705 - 817 */
1464 },
1465 { 32, 24, 711, 512, "xfd",
1466 { 0, 40704 }, /* a cyl 0 - 52 */
1467 { 40704, 40704 }, /* b cyl 53 - 105 */
1468 { 81408, 460800 }, /* c cyl 106 - 705 */
1469 { 0, 81408 }, /* d cyl 709 - 710 (a & b) */
1470 { 0, 542208 }, /* e cyl 0 - 705 */
1471 { 40704, 501504 }, /* f cyl 53 - 705 (b & c) */
1472 { 81408, 230400 }, /* g cyl 106 - 405 (1/2 of c) */
1473 { 311808,230400 } /* h cyl 406 - 705 (1/2 of c) */
1474 },
1475 { 32, 19, 823, 512, "smd",
1476 {0, 40128}, /* a cyl 0-65 */
1477 {40128, 27360}, /* b cyl 66-110 */
1478 {67488, 429856}, /* c cyl 111-817 */
1479 {139232, 358112}, /* d cyl 229 - 817 */
1480 {210976, 286368}, /* e cyl 347 - 817 */
1481 {282720, 214624}, /* f cyl 465 - 817 */
1482 {354464, 142880}, /* g cyl 583 - 817 */
1483 {426208, 71136} /* h cyl 701 - 817 */
1484 },
1485 { 18, 15, 1224, 1024, "mxd",
1486 {0, 21600}, /* a cyl 0-79 */
1487 {21600, 22410}, /* b cyl 80-162 */
1488 {44010, 285120}, /* c cyl 163-1217 */
1489 #ifdef notyet
1490 {x, 237600}, /* d cyl y - 1217 */
1491 {x, 190080}, /* e cyl y - 1217 */
1492 {x, 142560}, /* f cyl y - 1217 */
1493 {x, 95040}, /* g cyl y - 1217 */
1494 {x, 47520} /* h cyl 701 - 817 */
1495 #endif
1496 },
1497 { 32, 10, 823, 512, "fsd",
1498 {0, 19200}, /* a cyl 0 - 59 */
1499 {19200, 24000}, /* b cyl 60 - 134 */
1500 {43200, 218560}, /* c cyl 135 - 817 */
1501 }
1502 };
1503 #define NVDST (sizeof (vdst) / sizeof (vdst[0]))
1504
1505 /*
1506 * Construct a label for an unlabeled pack. We
1507 * deduce the drive type by reading from the last
1508 * track on successively smaller drives until we
1509 * don't get an error.
1510 */
vdmaptype(vi,lp)1511 vdmaptype(vi, lp)
1512 register struct vba_device *vi;
1513 register struct disklabel *lp;
1514 {
1515 register struct vdsoftc *vd;
1516 register struct vdst *p;
1517 struct vba_ctlr *vm = vi->ui_mi;
1518 int i;
1519
1520 vd = &vdsoftc[vi->ui_ctlr];
1521 for (p = vdst; p < &vdst[NVDST]; p++) {
1522 if (vd->vd_type == VDTYPE_VDDC && p->nsec != 32)
1523 continue;
1524 lp->d_nsectors = p->nsec;
1525 lp->d_ntracks = p->ntrack;
1526 lp->d_ncylinders = p->ncyl;
1527 lp->d_secsize = p->secsize;
1528 DELAY(100000);
1529 if (!vdreset_drive(vi))
1530 return (0);
1531 DELAY(100000);
1532 vd->vd_dcb.opcode = VDOP_RD;
1533 vd->vd_dcb.intflg = DCBINT_NONE;
1534 vd->vd_dcb.nxtdcb = (struct dcb *)0; /* end of chain */
1535 vd->vd_dcb.devselect = dksoftc[vi->ui_unit].dk_dcb.devselect;
1536 vd->vd_dcb.trailcnt = sizeof (struct trrw) / sizeof (long);
1537 vd->vd_dcb.trail.rwtrail.memadr =
1538 vtoph((struct proc *)0, (unsigned)vd->vd_rbuf.vb_rawbuf);
1539 vd->vd_dcb.trail.rwtrail.wcount = lp->d_secsize / sizeof(short);
1540 vd->vd_dcb.operrsta = 0;
1541 vd->vd_dcb.trail.rwtrail.disk.cylinder = p->ncyl - 2;
1542 vd->vd_dcb.trail.rwtrail.disk.track = p->ntrack - 1;
1543 vd->vd_dcb.trail.rwtrail.disk.sector = p->nsec - 1;
1544 vd->vd_mdcb.mdcb_head = (struct dcb *)vd->vd_dcbphys;
1545 vd->vd_mdcb.mdcb_status = 0;
1546 VDGO(vm->um_addr, vd->vd_mdcbphys, vd->vd_type);
1547 if (!vdpoll(vm, 60))
1548 printf(" during probe\n");
1549 if ((vd->vd_dcb.operrsta & VDERR_HARD) == 0)
1550 break;
1551 }
1552 if (p >= &vdst[NVDST])
1553 return (0);
1554
1555 for (i = 0; i < 8; i++) {
1556 lp->d_partitions[i].p_offset = p->parts[i].off;
1557 lp->d_partitions[i].p_size = p->parts[i].size;
1558 }
1559 lp->d_npartitions = 8;
1560 lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
1561 bcopy(p->name, lp->d_typename, 4);
1562 return (1);
1563 }
1564 #endif COMPAT_42
1565 #endif
1566