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