![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoevba|
Return to hd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoevba |
1.1 root 1: /*
2: * Copyright (c) 1988 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Harris Corp.
7: *
8: * Redistribution is only permitted until one year after the first shipment
9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
10: * binary forms are permitted provided that: (1) source distributions retain
11: * this entire copyright notice and comment, and (2) distributions including
12: * binaries display the following acknowledgement: This product includes
13: * software developed by the University of California, Berkeley and its
14: * contributors'' in the documentation or other materials provided with the
15: * distribution and in all advertising materials mentioning features or use
16: * of this software. Neither the name of the University nor the names of
17: * its contributors may be used to endorse or promote products derived from
18: * this software without specific prior written permission.
19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22: *
23: * @(#)hd.c 7.11 (Berkeley) 6/28/90
24: */
25:
26: #include "hd.h"
27:
28: #if NHD > 0
29: #include "param.h"
30: #include "buf.h"
31: #include "conf.h"
32: #include "dkstat.h"
33: #include "disklabel.h"
34: #include "file.h"
35: #include "systm.h"
36: #include "vmmac.h"
37: #include "time.h"
38: #include "proc.h"
39: #include "uio.h"
40: #include "syslog.h"
41: #include "kernel.h"
42: #include "ioctl.h"
43: #include "stat.h"
44: #include "errno.h"
45:
46: #include "../tahoe/cpu.h"
47: #include "../tahoe/mtpr.h"
48:
49: #include "../tahoevba/vbavar.h"
50: #include "../tahoevba/hdreg.h"
51:
52: #define b_cylin b_resid
53:
54: #define hdunit(dev) (minor(dev)>>3)
55: #define hdpart(dev) (minor(dev)&0x07)
56: #define hdminor(unit, part) (((unit)<<3)|(part))
57:
58: struct vba_ctlr *hdcminfo[NHDC];
59: struct vba_device *hddinfo[NHD];
60: int hdcprobe(), hdslave(), hdattach(), hddgo(), hdstrategy();
61: long hdstd[] = { 0 };
62: struct vba_driver hdcdriver =
63: { hdcprobe, hdslave, hdattach, hddgo, hdstd, "hd", hddinfo, "hdc", hdcminfo };
64:
65: /*
66: * Per-controller state.
67: */
68: struct hdcsoftc {
69: u_short hdc_flags;
70: #define HDC_INIT 0x01 /* controller initialized */
71: #define HDC_STARTED 0x02 /* start command issued */
72: #define HDC_LOCKED 0x04 /* locked for direct controller access */
73: #define HDC_WAIT 0x08 /* someone needs direct controller access */
74: u_short hdc_wticks; /* timeout */
75: struct master_mcb *hdc_mcbp; /* address of controller mcb */
76: struct registers *hdc_reg; /* base address of i/o regs */
77: struct vb_buf hdc_rbuf; /* vba resources */
78: struct master_mcb hdc_mcb; /* controller mcb */
79: } hdcsoftc[NHDC];
80:
81: #define HDCMAXTIME 20 /* max time for operation, sec. */
82: #define HDCINTERRUPT 0xf0 /* interrupt vector */
83:
84: /*
85: * Per-drive state; probably everything should be "hd_", not "dk_",
86: * but it's not worth it, and dk is a better mnemonic for disk anyway.
87: */
88: struct dksoftc {
89: #ifdef COMPAT_42
90: u_short dk_def_cyl; /* definition track cylinder address */
91: #endif
92: int dk_state; /* open fsm */
93: u_short dk_bshift; /* shift for * (DEV_BSIZE / sectorsize) XXX */
94: int dk_wlabel; /* if label sector is writeable */
95: u_long dk_copenpart; /* character units open on this drive */
96: u_long dk_bopenpart; /* block units open on this drive */
97: u_long dk_openpart; /* all units open on this drive */
98: int dk_unit; /* unit# */
99: int dk_ctlr; /* controller# */
100: int dk_format; /* if format program is using disk */
101: struct buf dk_utab; /* i/o queue header */
102: struct disklabel dk_label; /* disklabel for this disk */
103: struct mcb dk_mcb; /* disk mcb */
104: } dksoftc[NHD];
105:
106: /*
107: * Drive states. Used during steps of open/initialization.
108: * States < OPEN (> 0) are transient, during an open operation.
109: * OPENRAW is used for unlabeled disks, to allow format operations.
110: */
111: #define CLOSED 0 /* disk is closed */
112: #define WANTOPEN 1 /* open requested, not started */
113: #define WANTOPENRAW 2 /* open requested, no label */
114: #define RDLABEL 3 /* reading pack label */
115: #define OPEN 4 /* intialized and ready */
116: #define OPENRAW 5 /* open, no label */
117:
118: int hdcwstart, hdcwatch();
119:
120: /* see if the controller is really there, if so, init it. */
121: /* ARGSUSED */
122: hdcprobe(reg, vm)
123: caddr_t reg;
124: /* register */ struct vba_ctlr *vm;
125: {
126: register int br, cvec; /* must be r12, r11 */
127: register struct hdcsoftc *hdc;
128: static struct module_id id;
129: struct pte *dummypte;
130: caddr_t putl;
131:
132: /* initialize the hdc controller structure. */
133: hdc = &hdcsoftc[vm->um_ctlr];
134: if (!vbmemalloc(1, reg, &dummypte, &putl)) {
135: printf("hdc%d: vbmemalloc failed.\n", vm->um_ctlr);
136: return(0);
137: }
138: hdc->hdc_reg = (struct registers *)putl;
139:
140: /*
141: * try and ping the MID register; side effect of wbadaddr is to read
142: * the module id; the controller is bad if it's not an hdc, the hdc's
143: * writeable control store is not loaded, or the hdc failed the
144: * functional integrity test;
145: */
146: if (wbadaddr(&hdc->hdc_reg->module_id, 4,
147: vtoph((struct process *)NULL, &id)))
148: return(0);
149: DELAY(10000);
150: mtpr(PADC, 0);
151: if (id.module_id != (u_char)HDC_MID) {
152: printf("hdc%d: bad module id; id = %x.\n",
153: vm->um_ctlr, id.module_id);
154: return(0);
155: }
156: if (id.code_rev == (u_char)0xff) {
157: printf("hdc%d: micro-code not loaded.\n", vm->um_ctlr);
158: return(0);
159: }
160: if (id.fit != (u_char)0xff) {
161: printf("hdc%d: FIT test failed.\n", vm->um_ctlr);
162: return(0);
163: }
164:
165: /* reset that pup; flag as inited */
166: hdc->hdc_reg->soft_reset = 0;
167: DELAY(1000000);
168: hdc->hdc_flags |= HDC_INIT;
169:
170: /* allocate page tables and i/o buffer. */
171: if (!vbainit(&hdc->hdc_rbuf, MAXPHYS, VB_32BIT|VB_SCATTER)) {
172: printf("hdc%d: vbainit failed\n", vm->um_ctlr);
173: return (0);
174: }
175:
176: /* set pointer to master control block */
177: hdc->hdc_mcbp =
178: (struct master_mcb *)vtoph((struct proc *)NULL, &hdc->hdc_mcb);
179:
180: br = 0x17, cvec = HDCINTERRUPT + vm->um_ctlr; /* XXX */
181: return(sizeof(struct registers));
182: }
183:
184: /* ARGSUSED */
185: hdslave(vi, vdaddr)
186: struct vba_device *vi;
187: struct vddevice *vdaddr;
188: {
189: register struct mcb *mcb;
190: register struct disklabel *lp;
191: register struct dksoftc *dk;
192: static struct status status;
193:
194: dk = &dksoftc[vi->ui_unit];
195: dk->dk_unit = vi->ui_unit;
196: dk->dk_ctlr = vi->ui_ctlr;
197:
198: mcb = &dk->dk_mcb;
199: mcb->command = HCMD_STATUS;
200: mcb->chain[0].wcount = sizeof(struct status) / sizeof(long);
201: mcb->chain[0].memadr = (u_long)vtoph((struct process *)0, &status);
202: if (hdimcb(dk)) {
203: printf(" (no status)\n");
204: return(0);
205: }
206:
207: /*
208: * Report the drive down if anything in the drive status looks bad.
209: * If the drive is offline and it is not on cylinder, then the drive
210: * is not there. If there is a fault condition, the hdc will try to
211: * clear it when we read the disklabel information.
212: */
213: if (!(status.drs&DRS_ONLINE)) {
214: if (status.drs&DRS_ON_CYLINDER)
215: printf(" (not online)\n");
216: return(0);
217: }
218: if (status.drs&DRS_FAULT)
219: printf(" (clearing fault)");
220:
221: lp = &dk->dk_label;
222: #ifdef RAW_SIZE
223: lp->d_secsize = status.bytes_per_sec;
224: #else
225: lp->d_secsize = 512;
226: #endif
227: lp->d_nsectors = status.max_sector + 1;
228: lp->d_ntracks = status.max_head + 1;
229: lp->d_ncylinders = status.max_cyl + 1;
230: lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
231: lp->d_npartitions = 1;
232: lp->d_partitions[0].p_offset = 0;
233: lp->d_partitions[0].p_size = LABELSECTOR + 1;
234: lp->d_rpm = status.rpm;
235: lp->d_typename[0] = 'h';
236: lp->d_typename[1] = 'd';
237: lp->d_typename[2] = '\0';
238: #ifdef COMPAT_42
239: dk->dk_def_cyl = status.def_cyl;
240: #endif
241: return(1);
242: }
243:
244: hdattach(vi)
245: register struct vba_device *vi;
246: {
247: register struct dksoftc *dk;
248: register struct disklabel *lp;
249: register int unit;
250:
251: unit = vi->ui_unit;
252: if (hdinit(hdminor(unit, 0), 0)) {
253: printf(": unknown drive type");
254: return;
255: }
256: dk = &dksoftc[unit];
257: lp = &dk->dk_label;
258: hd_setsecsize(dk, lp);
259: if (dk->dk_state == OPEN)
260: printf(": %s <secsize %d, ntrak %d, ncyl %d, nsec %d>",
261: lp->d_typename, lp->d_secsize, lp->d_ntracks,
262: lp->d_ncylinders, lp->d_nsectors);
263:
264: /*
265: * (60 / rpm) / (sectors per track * (bytes per sector / 2))
266: */
267: if (vi->ui_dk >= 0)
268: dk_wpms[vi->ui_dk] =
269: (lp->d_rpm * lp->d_nsectors * lp->d_secsize) / 120;
270: #ifdef notyet
271: addswap(makedev(HDMAJOR, hdminor(unit, 0)), lp);
272: #endif
273: }
274:
275: hdopen(dev, flags, fmt)
276: dev_t dev;
277: int flags, fmt;
278: {
279: register struct disklabel *lp;
280: register struct dksoftc *dk;
281: register struct partition *pp;
282: register int unit;
283: struct vba_device *vi;
284: int s, error, part = hdpart(dev), mask = 1 << part;
285: daddr_t start, end;
286:
287: unit = hdunit(dev);
288: if (unit >= NHD || (vi = hddinfo[unit]) == 0 || vi->ui_alive == 0)
289: return(ENXIO);
290: dk = &dksoftc[unit];
291: lp = &dk->dk_label;
292: s = spl7();
293: while (dk->dk_state != OPEN && dk->dk_state != OPENRAW &&
294: dk->dk_state != CLOSED)
295: if (error = tsleep((caddr_t)dk, (PZERO+1) | PCATCH,
296: devopn, 0)) {
297: splx(s);
298: return (error);
299: }
300: splx(s);
301: if (dk->dk_state != OPEN && dk->dk_state != OPENRAW)
302: if (error = hdinit(dev, flags))
303: return(error);
304:
305: if (hdcwstart == 0) {
306: timeout(hdcwatch, (caddr_t)0, hz);
307: hdcwstart++;
308: }
309: /*
310: * Warn if a partion is opened that overlaps another partition
311: * which is open unless one is the "raw" partition (whole disk).
312: */
313: #define RAWPART 8 /* 'x' partition */ /* XXX */
314: if ((dk->dk_openpart & mask) == 0 && part != RAWPART) {
315: pp = &lp->d_partitions[part];
316: start = pp->p_offset;
317: end = pp->p_offset + pp->p_size;
318: for (pp = lp->d_partitions;
319: pp < &lp->d_partitions[lp->d_npartitions]; pp++) {
320: if (pp->p_offset + pp->p_size <= start ||
321: pp->p_offset >= end)
322: continue;
323: if (pp - lp->d_partitions == RAWPART)
324: continue;
325: if (dk->dk_openpart & (1 << (pp - lp->d_partitions)))
326: log(LOG_WARNING,
327: "hd%d%c: overlaps open partition (%c)\n",
328: unit, part + 'a',
329: pp - lp->d_partitions + 'a');
330: }
331: }
332: if (part >= lp->d_npartitions)
333: return(ENXIO);
334: dk->dk_openpart |= mask;
335: switch (fmt) {
336: case S_IFCHR:
337: dk->dk_copenpart |= mask;
338: break;
339: case S_IFBLK:
340: dk->dk_bopenpart |= mask;
341: break;
342: }
343: return(0);
344: }
345:
346: /* ARGSUSED */
347: hdclose(dev, flags, fmt)
348: dev_t dev;
349: int flags, fmt;
350: {
351: register struct dksoftc *dk;
352: int mask;
353:
354: dk = &dksoftc[hdunit(dev)];
355: mask = 1 << hdpart(dev);
356: switch (fmt) {
357: case S_IFCHR:
358: dk->dk_copenpart &= ~mask;
359: break;
360: case S_IFBLK:
361: dk->dk_bopenpart &= ~mask;
362: break;
363: }
364: if (((dk->dk_copenpart | dk->dk_bopenpart) & mask) == 0)
365: dk->dk_openpart &= ~mask;
366: /*
367: * Should wait for i/o to complete on this partition
368: * even if others are open, but wait for work on blkflush().
369: */
370: if (dk->dk_openpart == 0) {
371: int s = spl7();
372: while (dk->dk_utab.b_actf)
373: sleep((caddr_t)dk, PZERO-1);
374: splx(s);
375: dk->dk_state = CLOSED;
376: dk->dk_wlabel = 0;
377: }
378: return(0);
379: }
380:
381: hdinit(dev, flags)
382: dev_t dev;
383: int flags;
384: {
385: register struct dksoftc *dk;
386: register struct disklabel *lp;
387: struct vba_device *vi;
388: int error, unit;
389: char *msg, *readdisklabel();
390: extern int cold;
391:
392: vi = hddinfo[unit = hdunit(dev)];
393: dk = &dksoftc[unit];
394: dk->dk_unit = vi->ui_slave;
395: dk->dk_ctlr = vi->ui_ctlr;
396:
397: if (flags & O_NDELAY) {
398: dk->dk_state = OPENRAW;
399: return(0);
400: }
401:
402: error = 0;
403: lp = &dk->dk_label;
404: dk->dk_state = RDLABEL;
405: if (msg = readdisklabel(dev, hdstrategy, lp)) {
406: if (cold) {
407: printf(": %s\n", msg);
408: dk->dk_state = CLOSED;
409: } else {
410: log(LOG_ERR, "hd%d: %s\n", unit, msg);
411: dk->dk_state = OPENRAW;
412: }
413: #ifdef COMPAT_42
414: hdclock(vi->ui_ctlr);
415: if (!(error = hdreadgeometry(dk)))
416: dk->dk_state = OPEN;
417: hdcunlock(vi->ui_ctlr);
418: #endif
419: } else
420: dk->dk_state = OPEN;
421: wakeup((caddr_t)dk);
422: return(error);
423: }
424:
425: hd_setsecsize(dk, lp)
426: register struct dksoftc *dk;
427: struct disklabel *lp;
428: {
429: register int mul;
430:
431: /*
432: * Calculate scaling shift for mapping
433: * DEV_BSIZE blocks to drive sectors.
434: */
435: mul = DEV_BSIZE / lp->d_secsize;
436: dk->dk_bshift = 0;
437: while ((mul >>= 1) > 0)
438: dk->dk_bshift++;
439: }
440:
441: /* ARGSUSED */
442: hddgo(vm)
443: struct vba_device *vm;
444: {}
445:
446: extern int name_ext;
447: hdstrategy(bp)
448: register struct buf *bp;
449: {
450: register struct vba_device *vi;
451: register struct disklabel *lp;
452: register struct dksoftc *dk;
453: struct buf *dp;
454: register int unit;
455: daddr_t sn, sz, maxsz;
456: int part, s;
457:
458: vi = hddinfo[unit = hdunit(bp->b_dev)];
459: if (unit >= NHD || vi == 0 || vi->ui_alive == 0) {
460: bp->b_error = ENXIO;
461: goto bad;
462: }
463: dk = &dksoftc[unit];
464: if (dk->dk_state < OPEN)
465: goto q;
466: if (dk->dk_state != OPEN && (bp->b_flags & B_READ) == 0) {
467: bp->b_error = EROFS;
468: goto bad;
469: }
470: part = hdpart(bp->b_dev);
471: if ((dk->dk_openpart & (1 << part)) == 0) {
472: bp->b_error = ENODEV;
473: goto bad;
474: }
475: lp = &dk->dk_label;
476: sz = (bp->b_bcount + lp->d_secsize - 1) / lp->d_secsize;
477: maxsz = lp->d_partitions[part].p_size;
478: sn = bp->b_blkno << dk->dk_bshift;
479: if (sn + lp->d_partitions[part].p_offset <= LABELSECTOR &&
480: #if LABELSECTOR != 0
481: sn + lp->d_partitions[part].p_offset + sz > LABELSECTOR &&
482: #endif
483: (bp->b_flags & B_READ) == 0 && dk->dk_wlabel == 0) {
484: bp->b_error = EROFS;
485: goto bad;
486: }
487: if (sn < 0 || sn + sz > maxsz) {
488: if (sn == maxsz) {
489: bp->b_resid = bp->b_bcount;
490: goto done;
491: }
492: sz = maxsz - sn;
493: if (sz <= 0) {
494: bp->b_error = EINVAL;
495: goto bad;
496: }
497: bp->b_bcount = sz * lp->d_secsize;
498: }
499: bp->b_cylin = (sn + lp->d_partitions[part].p_offset) / lp->d_secpercyl;
500:
501: q: s = spl7();
502: dp = &dk->dk_utab;
503: disksort(dp, bp);
504: if (!dp->b_active) {
505: (void)hdustart(vi);
506: if (!vi->ui_mi->um_tab.b_active)
507: hdcstart(vi->ui_mi);
508: }
509: splx(s);
510: return;
511: bad:
512: bp->b_flags |= B_ERROR;
513: done:
514: biodone(bp);
515: }
516:
517: hdustart(vi)
518: register struct vba_device *vi;
519: {
520: register struct buf *bp, *dp;
521: register struct vba_ctlr *vm;
522: register struct dksoftc *dk;
523:
524: dk = &dksoftc[vi->ui_unit];
525: dp = &dk->dk_utab;
526:
527: /* if queue empty, nothing to do. impossible? */
528: if (dp->b_actf == NULL)
529: return;
530:
531: /* place on controller transfer queue */
532: vm = vi->ui_mi;
533: if (vm->um_tab.b_actf == NULL)
534: vm->um_tab.b_actf = dp;
535: else
536: vm->um_tab.b_actl->b_forw = dp;
537: vm->um_tab.b_actl = dp;
538: dp->b_forw = NULL;
539: dp->b_active++;
540: }
541:
542: hdcstart(vm)
543: register struct vba_ctlr *vm;
544: {
545: register struct buf *bp;
546: register struct dksoftc *dk;
547: register struct disklabel *lp;
548: register struct master_mcb *master;
549: register struct mcb *mcb;
550: struct vba_device *vi;
551: struct hdcsoftc *hdc;
552: struct buf *dp;
553: int sn;
554:
555: /* pull a request off the controller queue */
556: for (;;) {
557: if ((dp = vm->um_tab.b_actf) == NULL)
558: return;
559: if (bp = dp->b_actf)
560: break;
561: vm->um_tab.b_actf = dp->b_forw;
562: }
563:
564: /* mark controller active */
565: vm->um_tab.b_active++;
566:
567: vi = hddinfo[hdunit(bp->b_dev)];
568: dk = &dksoftc[vi->ui_unit];
569: lp = &dk->dk_label;
570: sn = bp->b_blkno << dk->dk_bshift;
571:
572: /* fill in mcb */
573: mcb = &dk->dk_mcb;
574: mcb->forw_phaddr = 0;
575: /* mcb->priority = 0; */
576: mcb->interrupt = 1;
577: mcb->command = (bp->b_flags & B_READ) ? HCMD_READ:HCMD_WRITE;
578: mcb->cyl = bp->b_cylin;
579: /* assumes partition starts on cylinder boundary */
580: mcb->head = (sn / lp->d_nsectors) % lp->d_ntracks;
581: mcb->sector = sn % lp->d_nsectors;
582: mcb->drive = vi->ui_slave;
583: /* mcb->context = 0; /* what do we want on interrupt? */
584:
585: hdc = &hdcsoftc[vm->um_ctlr];
586: if (!hd_sgsetup(bp, &hdc->hdc_rbuf, mcb->chain)) {
587: mcb->chain[0].wcount = (bp->b_bcount+3) >> 2;
588: mcb->chain[0].memadr =
589: vbasetup(bp, &hdc->hdc_rbuf, (int)lp->d_secsize);
590: }
591:
592: if (vi->ui_dk >= 0) {
593: dk_busy |= 1<<vi->ui_dk;
594: dk_xfer[vi->ui_dk]++;
595: dk_wds[vi->ui_dk] += bp->b_bcount>>6;
596: }
597:
598: master = &hdc->hdc_mcb;
599: master->mcw = MCL_QUEUED;
600: master->interrupt = HDCINTERRUPT + vm->um_ctlr;
601: master->forw_phaddr = (u_long)vtoph((struct proc *)NULL, mcb);
602: hdc->hdc_reg->master_mcb = (u_long)hdc->hdc_mcbp;
603: }
604:
605: /*
606: * Wait for controller to finish current operation
607: * so that direct controller accesses can be done.
608: */
609: hdclock(ctlr)
610: int ctlr;
611: {
612: register struct vba_ctlr *vm = hdcminfo[ctlr];
613: register struct hdcsoftc *hdc;
614: int s;
615:
616: hdc = &hdcsoftc[ctlr];
617: s = spl7();
618: while (vm->um_tab.b_active || hdc->hdc_flags & HDC_LOCKED) {
619: hdc->hdc_flags |= HDC_WAIT;
620: sleep((caddr_t)hdc, PRIBIO);
621: }
622: hdc->hdc_flags |= HDC_LOCKED;
623: splx(s);
624: }
625:
626: /*
627: * Continue normal operations after pausing for
628: * munging the controller directly.
629: */
630: hdcunlock(ctlr)
631: int ctlr;
632: {
633: register struct vba_ctlr *vm;
634: register struct hdcsoftc *hdc = &hdcsoftc[ctlr];
635:
636: hdc->hdc_flags &= ~HDC_LOCKED;
637: if (hdc->hdc_flags & HDC_WAIT) {
638: hdc->hdc_flags &= ~HDC_WAIT;
639: wakeup((caddr_t)hdc);
640: } else {
641: vm = hdcminfo[ctlr];
642: if (vm->um_tab.b_actf)
643: hdcstart(vm);
644: }
645: }
646:
647: hdintr(ctlr)
648: int ctlr;
649: {
650: register struct buf *bp, *dp;
651: register struct vba_ctlr *vm;
652: register struct vba_device *vi;
653: register struct hdcsoftc *hdc;
654: register struct mcb *mcb;
655: struct master_mcb *master;
656: register int status;
657: int timedout;
658: struct dksoftc *dk;
659:
660: hdc = &hdcsoftc[ctlr];
661: master = &hdc->hdc_mcb;
662: uncache(&master->mcs);
663: uncache(&master->context);
664:
665: vm = hdcminfo[ctlr];
666: if (!vm->um_tab.b_active || !(master->mcs&MCS_DONE)) {
667: printf("hd%d: stray interrupt\n", ctlr);
668: return;
669: }
670:
671: dp = vm->um_tab.b_actf;
672: bp = dp->b_actf;
673: vi = hddinfo[hdunit(bp->b_dev)];
674: dk = &dksoftc[vi->ui_unit];
675: if (vi->ui_dk >= 0)
676: dk_busy &= ~(1<<vi->ui_dk);
677: timedout = (hdc->hdc_wticks >= HDCMAXTIME);
678:
679: mcb = &dk->dk_mcb;
680:
681: if (master->mcs & (MCS_SOFTERROR | MCS_FATALERROR) || timedout)
682: hdcerror(ctlr, *(u_long *)master->xstatus);
683: else
684: hdc->hdc_wticks = 0;
685: if (vm->um_tab.b_active) {
686: vm->um_tab.b_active = 0;
687: vm->um_tab.b_actf = dp->b_forw;
688: dp->b_active = 0;
689: dp->b_errcnt = 0;
690: dp->b_actf = bp->av_forw;
691: bp->b_resid = 0;
692: vbadone(bp, &hdc->hdc_rbuf);
693: biodone(bp);
694: /* start up now, if more work to do */
695: if (dp->b_actf)
696: hdustart(vi);
697: else if (dk->dk_openpart == 0)
698: wakeup((caddr_t)dk);
699: }
700: /* if there are devices ready to transfer, start the controller. */
701: if (hdc->hdc_flags & HDC_WAIT) {
702: hdc->hdc_flags &= ~HDC_WAIT;
703: wakeup((caddr_t)hdc);
704: } else if (vm->um_tab.b_actf)
705: hdcstart(vm);
706: }
707:
708: hdioctl(dev, cmd, data, flag)
709: dev_t dev;
710: int cmd, flag;
711: caddr_t data;
712: {
713: register int unit;
714: register struct dksoftc *dk;
715: register struct disklabel *lp;
716: int error;
717:
718: unit = hdunit(dev);
719: dk = &dksoftc[unit];
720: lp = &dk->dk_label;
721: error = 0;
722: switch (cmd) {
723: case DIOCGDINFO:
724: *(struct disklabel *)data = *lp;
725: break;
726: case DIOCGPART:
727: ((struct partinfo *)data)->disklab = lp;
728: ((struct partinfo *)data)->part =
729: &lp->d_partitions[hdpart(dev)];
730: break;
731: case DIOCSDINFO:
732: if ((flag & FWRITE) == 0)
733: error = EBADF;
734: else
735: error = setdisklabel(lp, (struct disklabel *)data,
736: (dk->dk_state == OPENRAW) ? 0 : dk->dk_openpart);
737: if (error == 0 && dk->dk_state == OPENRAW)
738: dk->dk_state = OPEN;
739: break;
740: case DIOCWLABEL:
741: if ((flag & FWRITE) == 0)
742: error = EBADF;
743: else
744: dk->dk_wlabel = *(int *)data;
745: break;
746: case DIOCWDINFO:
747: if ((flag & FWRITE) == 0)
748: error = EBADF;
749: else if ((error = setdisklabel(lp, (struct disklabel *)data,
750: (dk->dk_state == OPENRAW) ? 0 : dk->dk_openpart)) == 0) {
751: int wlab;
752:
753: if (error == 0 && dk->dk_state == OPENRAW)
754: dk->dk_state = OPEN;
755: /* simulate opening partition 0 so write succeeds */
756: dk->dk_openpart |= (1 << 0); /* XXX */
757: wlab = dk->dk_wlabel;
758: dk->dk_wlabel = 1;
759: error = writedisklabel(dev, hdstrategy, lp);
760: dk->dk_openpart = dk->dk_copenpart | dk->dk_bopenpart;
761: dk->dk_wlabel = wlab;
762: }
763: break;
764: default:
765: error = ENOTTY;
766: break;
767: }
768: return (error);
769: }
770:
771: /*
772: * Watch for lost interrupts.
773: */
774: hdcwatch()
775: {
776: register struct hdcsoftc *hdc;
777: register struct vba_ctlr **vmp;
778: register int ctlr;
779: int s;
780:
781: timeout(hdcwatch, (caddr_t)0, hz);
782: for (vmp = hdcminfo, hdc = hdcsoftc, ctlr = 0; ctlr < NHDC;
783: ++ctlr, ++vmp, ++hdc) {
784: if (*vmp == 0 || (*vmp)->um_alive == 0)
785: continue;
786: s = spl7();
787: if ((*vmp)->um_tab.b_active &&
788: hdc->hdc_wticks++ >= HDCMAXTIME) {
789: printf("hd%d: lost interrupt\n", ctlr);
790: hdintr(ctlr);
791: }
792: splx(s);
793: }
794: }
795:
796: hddump(dev)
797: dev_t dev;
798: {
799: return(ENXIO);
800: }
801:
802: hdsize(dev)
803: dev_t dev;
804: {
805: register int unit = hdunit(dev);
806: register struct dksoftc *dk;
807: struct vba_device *vi;
808: struct disklabel *lp;
809:
810: if (unit >= NHD || (vi = hddinfo[unit]) == 0 || vi->ui_alive == 0 ||
811: (dk = &dksoftc[unit])->dk_state != OPEN)
812: return (-1);
813: lp = &dk->dk_label;
814: return ((int)lp->d_partitions[hdpart(dev)].p_size >> dk->dk_bshift);
815: }
816:
817: hdimcb(dk)
818: register struct dksoftc *dk;
819: {
820: register struct master_mcb *master;
821: register struct mcb *mcb;
822: register struct hdcsoftc *hdc;
823: int timeout;
824:
825: /* fill in mcb */
826: mcb = &dk->dk_mcb;
827: mcb->interrupt = 0;
828: mcb->forw_phaddr = 0;
829: mcb->drive = dk->dk_unit;
830:
831: hdc = &hdcsoftc[dk->dk_ctlr];
832: master = &hdc->hdc_mcb;
833:
834: /* fill in master mcb */
835: master->mcw = MCL_IMMEDIATE;
836: master->forw_phaddr = (u_long)vtoph((struct proc *)NULL, mcb);
837: master->mcs = 0;
838:
839: /* kick controller and wait */
840: hdc->hdc_reg->master_mcb = (u_long)hdc->hdc_mcbp;
841: for (timeout = 15000; timeout; --timeout) {
842: DELAY(1000);
843: mtpr(PADC, 0);
844: if (master->mcs&MCS_FATALERROR) {
845: printf("hdc%d: fatal error\n", dk->dk_ctlr);
846: hdcerror(dk->dk_ctlr, *(u_long *)master->xstatus);
847: return(1);
848: }
849: if (master->mcs&MCS_DONE)
850: return(0);
851: }
852: printf("hdc%d: timed out\n", dk->dk_ctlr);
853: return(1);
854: }
855:
856: hdcerror(ctlr, code)
857: int ctlr;
858: u_long code;
859: {
860: printf("hd%d: error %lx\n", ctlr, code);
861: }
862:
863: #ifdef COMPAT_42
864: hdreadgeometry(dk)
865: struct dksoftc *dk;
866: {
867: static geometry_sector geometry;
868: register struct mcb *mcb;
869: register struct disklabel *lp;
870: geometry_block *geo;
871: int cnt;
872:
873: /*
874: * Read the geometry block (at head = 0 sector = 0 of the drive
875: * definition cylinder), validate it (must have the correct version
876: * number, header, and checksum).
877: */
878: mcb = &dk->dk_mcb;
879: mcb->command = HCMD_READ;
880: mcb->cyl = dk->dk_def_cyl;
881: mcb->head = 0;
882: mcb->sector = 0;
883: mcb->chain[0].wcount = sizeof(geometry_sector) / sizeof(long);
884: mcb->chain[0].memadr = (u_long)vtoph((struct process *)0, &geometry);
885: /* mcb->chain[0].memadr = (long)&geometry; */
886: if (hdimcb(dk)) {
887: printf("hd%d: can't read default geometry.\n", dk->dk_unit);
888: return(1);
889: }
890: geo = &geometry.geometry_block;
891: if (geo->version > 64000 || geo->version < 0) {
892: printf("hd%d: bad default geometry version#.\n", dk->dk_unit);
893: return(1);
894: }
895: if (bcmp(&geo->id[0], GB_ID, GB_ID_LEN)) {
896: printf("hd%d: bad default geometry header.\n", dk->dk_unit);
897: return(1);
898: }
899: GB_CHECKSUM(geo, cnt);
900: if (geometry.checksum != cnt) {
901: printf("hd%d: bad default geometry checksum.\n", dk->dk_unit);
902: return(1);
903: }
904: lp = &dk->dk_label;
905:
906: /* 1K block in Harris geometry; convert to sectors for disklabels */
907: for (cnt = 0; cnt < GB_MAXPART; cnt++) {
908: lp->d_partitions[cnt].p_offset =
909: geo->partition[cnt].start * (1024 / lp->d_secsize);
910: lp->d_partitions[cnt].p_size =
911: geo->partition[cnt].length * (1024 / lp->d_secsize);
912: }
913: lp->d_npartitions = GB_MAXPART;
914: return(0);
915: }
916: #endif /* COMPAT_42 */
917: #endif /* NHD */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.