Annotation of sys/arch/vax/mba/hp.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: hp.c,v 1.18 2007/06/07 05:22:32 deraadt Exp $ */
! 2: /* $NetBSD: hp.c,v 1.22 2000/02/12 16:09:33 ragge Exp $ */
! 3: /*
! 4: * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
! 5: * All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: * 3. All advertising materials mentioning features or use of this software
! 16: * must display the following acknowledgement:
! 17: * This product includes software developed at Ludd, University of
! 18: * Lule}, Sweden and its contributors.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34: /*
! 35: * Simple device driver routine for massbuss disks.
! 36: * TODO:
! 37: * Fix support for Standard DEC BAD144 bad block forwarding.
! 38: * Be able to to handle soft/hard transfer errors.
! 39: * Handle non-data transfer interrupts.
! 40: * Autoconfiguration of disk drives 'on the fly'.
! 41: * Handle disk media changes.
! 42: * Dual-port operations should be supported.
! 43: */
! 44: #include <sys/param.h>
! 45: #include <sys/systm.h>
! 46: #include <sys/device.h>
! 47: #include <sys/disklabel.h>
! 48: #include <sys/disk.h>
! 49: #include <sys/dkio.h>
! 50: #include <sys/buf.h>
! 51: #include <sys/stat.h>
! 52: #include <sys/ioccom.h>
! 53: #include <sys/fcntl.h>
! 54: #include <sys/syslog.h>
! 55: #include <sys/reboot.h>
! 56:
! 57: #include <machine/trap.h>
! 58: #include <machine/pte.h>
! 59: #include <machine/mtpr.h>
! 60: #include <machine/cpu.h>
! 61: #include <machine/rpb.h>
! 62:
! 63: #include <vax/mba/mbavar.h>
! 64: #include <vax/mba/mbareg.h>
! 65: #include <vax/mba/hpreg.h>
! 66:
! 67: #define HPMASK 0xffff
! 68:
! 69: struct hp_softc {
! 70: struct device sc_dev;
! 71: struct disk sc_disk;
! 72: struct mba_device sc_md; /* Common struct used by mbaqueue. */
! 73: int sc_wlabel; /* Disklabel area is writable */
! 74: int sc_physnr; /* Physical disk number */
! 75: };
! 76:
! 77: int hpmatch(struct device *, struct cfdata *, void *);
! 78: void hpattach(struct device *, struct device *, void *);
! 79: void hpstrategy(struct buf *);
! 80: void hpstart(struct mba_device *);
! 81: int hpattn(struct mba_device *);
! 82: enum xfer_action hpfinish(struct mba_device *, int, int *);
! 83: int hpopen(dev_t, int, int);
! 84: int hpclose(dev_t, int, int);
! 85: int hpioctl(dev_t, u_long, caddr_t, int, struct proc *);
! 86: int hpdump(dev_t, daddr64_t, caddr_t, size_t);
! 87: int hpread(dev_t, struct uio *);
! 88: int hpwrite(dev_t, struct uio *);
! 89: daddr64_t hpsize(dev_t);
! 90:
! 91: struct cfattach hp_ca = {
! 92: sizeof(struct hp_softc), hpmatch, hpattach
! 93: };
! 94:
! 95: extern struct cfdriver hp_cd;
! 96:
! 97: /*
! 98: * Check if this is a disk drive; done by checking type from mbaattach.
! 99: */
! 100: int
! 101: hpmatch(parent, cf, aux)
! 102: struct device *parent;
! 103: struct cfdata *cf;
! 104: void *aux;
! 105: {
! 106: struct mba_attach_args *ma = aux;
! 107:
! 108: if (cf->cf_loc[MBACF_DRIVE] != MBACF_DRIVE_DEFAULT &&
! 109: cf->cf_loc[MBACF_DRIVE] != ma->unit)
! 110: return 0;
! 111:
! 112: if (ma->devtyp != MB_RP)
! 113: return 0;
! 114:
! 115: return 1;
! 116: }
! 117:
! 118: /*
! 119: * Disk drive found; fake a disklabel and try to read the real one.
! 120: * If the on-disk label can't be read; we lose.
! 121: */
! 122: void
! 123: hpattach(parent, self, aux)
! 124: struct device *parent, *self;
! 125: void *aux;
! 126: {
! 127: struct hp_softc *sc = (void *)self;
! 128: struct mba_softc *ms = (void *)parent;
! 129: struct disklabel *dl;
! 130: struct mba_attach_args *ma = aux;
! 131: char *msg;
! 132:
! 133: /*
! 134: * Init the common struct for both the adapter and its slaves.
! 135: */
! 136: BUFQ_INIT(&sc->sc_md.md_q);
! 137: sc->sc_md.md_softc = (void *)sc; /* Pointer to this softc */
! 138: sc->sc_md.md_mba = (void *)parent; /* Pointer to parent softc */
! 139: sc->sc_md.md_start = hpstart; /* Disk start routine */
! 140: sc->sc_md.md_attn = hpattn; /* Disk attention routine */
! 141: sc->sc_md.md_finish = hpfinish; /* Disk xfer finish routine */
! 142:
! 143: ms->sc_md[ma->unit] = &sc->sc_md; /* Per-unit backpointer */
! 144:
! 145: sc->sc_physnr = ma->unit;
! 146: /*
! 147: * Init and attach the disk structure.
! 148: */
! 149: sc->sc_disk.dk_name = sc->sc_dev.dv_xname;
! 150: disk_attach(&sc->sc_disk);
! 151:
! 152: /*
! 153: * Fake a disklabel to be able to read in the real label.
! 154: */
! 155: dl = sc->sc_disk.dk_label;
! 156:
! 157: dl->d_secsize = DEV_BSIZE;
! 158: dl->d_ntracks = 1;
! 159: dl->d_nsectors = 32;
! 160: dl->d_secpercyl = 32;
! 161:
! 162: /*
! 163: * Read in label.
! 164: */
! 165: if ((msg = readdisklabel(makedev(0, self->dv_unit * 8), hpstrategy,
! 166: dl, NULL)) != NULL) {
! 167: /*printf(": %s", msg);*/
! 168: }
! 169: printf(": %.*s, size = %d sectors\n",
! 170: (int)sizeof(dl->d_typename), dl->d_typename, DL_GETDSIZE(dl));
! 171: /*
! 172: * check if this was what we booted from.
! 173: */
! 174: if ((B_TYPE(bootdev) == BDEV_HP) && (ma->unit == B_UNIT(bootdev)) &&
! 175: (ms->sc_physnr == B_ADAPTOR(bootdev)))
! 176: booted_from = self;
! 177: }
! 178:
! 179:
! 180: void
! 181: hpstrategy(bp)
! 182: struct buf *bp;
! 183: {
! 184: struct hp_softc *sc;
! 185: struct buf *gp;
! 186: int unit, s;
! 187: struct disklabel *lp;
! 188:
! 189: unit = DISKUNIT(bp->b_dev);
! 190: sc = hp_cd.cd_devs[unit];
! 191: lp = sc->sc_disk.dk_label;
! 192:
! 193: if (bounds_check_with_label(bp, lp, sc->sc_wlabel) <= 0)
! 194: goto done;
! 195:
! 196: bp->b_rawblkno =
! 197: bp->b_blkno + DL_GETPOFFSET(&lp->d_partitions[DISKPART(bp->b_dev)]);
! 198: bp->b_cylinder = bp->b_rawblkno / lp->d_secpercyl;
! 199:
! 200: s = splbio();
! 201:
! 202: gp = BUFQ_FIRST(&sc->sc_md.md_q);
! 203: disksort_cylinder(&sc->sc_md.md_q, bp);
! 204: if (gp == 0)
! 205: mbaqueue(&sc->sc_md);
! 206:
! 207: splx(s);
! 208: return;
! 209:
! 210: done:
! 211: bp->b_resid = bp->b_bcount;
! 212: s = splbio();
! 213: biodone(bp);
! 214: splx(s);
! 215: }
! 216:
! 217: /*
! 218: * Start transfer on given disk. Called from mbastart().
! 219: */
! 220: void
! 221: hpstart(md)
! 222: struct mba_device *md;
! 223: {
! 224: struct hp_softc *sc = md->md_softc;
! 225: struct mba_regs *mr = md->md_mba->sc_mbareg;
! 226: volatile struct hp_regs *hr;
! 227: struct disklabel *lp = sc->sc_disk.dk_label;
! 228: struct buf *bp = BUFQ_FIRST(&md->md_q);
! 229: unsigned bn, cn, sn, tn;
! 230:
! 231: /*
! 232: * Collect statistics.
! 233: */
! 234: disk_busy(&sc->sc_disk);
! 235: sc->sc_disk.dk_seek++;
! 236:
! 237: hr = (void *)&mr->mba_md[DISKUNIT(bp->b_dev)];
! 238:
! 239: bn = bp->b_rawblkno;
! 240: if (bn) {
! 241: cn = bn / lp->d_secpercyl;
! 242: sn = bn % lp->d_secpercyl;
! 243: tn = sn / lp->d_nsectors;
! 244: sn = sn % lp->d_nsectors;
! 245: } else
! 246: cn = sn = tn = 0;
! 247:
! 248: hr->hp_dc = cn;
! 249: hr->hp_da = (tn << 8) | sn;
! 250: if (bp->b_flags & B_READ)
! 251: hr->hp_cs1 = HPCS_READ; /* GO */
! 252: else
! 253: hr->hp_cs1 = HPCS_WRITE;
! 254: }
! 255:
! 256: int
! 257: hpopen(dev, flag, fmt)
! 258: dev_t dev;
! 259: int flag, fmt;
! 260: {
! 261: struct hp_softc *sc;
! 262: int unit, part;
! 263:
! 264: unit = DISKUNIT(dev);
! 265: if (unit >= hp_cd.cd_ndevs)
! 266: return ENXIO;
! 267: sc = hp_cd.cd_devs[unit];
! 268: if (sc == 0)
! 269: return ENXIO;
! 270:
! 271: part = DISKPART(dev);
! 272:
! 273: if (part >= sc->sc_disk.dk_label->d_npartitions)
! 274: return ENXIO;
! 275:
! 276: switch (fmt) {
! 277: case S_IFCHR:
! 278: sc->sc_disk.dk_copenmask |= (1 << part);
! 279: break;
! 280:
! 281: case S_IFBLK:
! 282: sc->sc_disk.dk_bopenmask |= (1 << part);
! 283: break;
! 284: }
! 285: sc->sc_disk.dk_openmask =
! 286: sc->sc_disk.dk_copenmask | sc->sc_disk.dk_bopenmask;
! 287:
! 288: return 0;
! 289: }
! 290:
! 291: int
! 292: hpclose(dev, flag, fmt)
! 293: dev_t dev;
! 294: int flag, fmt;
! 295: {
! 296: struct hp_softc *sc;
! 297: int unit, part;
! 298:
! 299: unit = DISKUNIT(dev);
! 300: sc = hp_cd.cd_devs[unit];
! 301:
! 302: part = DISKPART(dev);
! 303:
! 304: switch (fmt) {
! 305: case S_IFCHR:
! 306: sc->sc_disk.dk_copenmask &= ~(1 << part);
! 307: break;
! 308:
! 309: case S_IFBLK:
! 310: sc->sc_disk.dk_bopenmask &= ~(1 << part);
! 311: break;
! 312: }
! 313: sc->sc_disk.dk_openmask =
! 314: sc->sc_disk.dk_copenmask | sc->sc_disk.dk_bopenmask;
! 315:
! 316: return 0;
! 317: }
! 318:
! 319: int
! 320: hpioctl(dev, cmd, addr, flag, p)
! 321: dev_t dev;
! 322: u_long cmd;
! 323: caddr_t addr;
! 324: int flag;
! 325: struct proc *p;
! 326: {
! 327: struct hp_softc *sc = hp_cd.cd_devs[DISKUNIT(dev)];
! 328: struct disklabel *lp = sc->sc_disk.dk_label;
! 329: int error;
! 330:
! 331: switch (cmd) {
! 332: case DIOCGDINFO:
! 333: bcopy(lp, addr, sizeof (struct disklabel));
! 334: return 0;
! 335:
! 336: case DIOCGPART:
! 337: ((struct partinfo *)addr)->disklab = lp;
! 338: ((struct partinfo *)addr)->part =
! 339: &lp->d_partitions[DISKPART(dev)];
! 340: break;
! 341:
! 342: case DIOCSDINFO:
! 343: if ((flag & FWRITE) == 0)
! 344: return EBADF;
! 345:
! 346: return setdisklabel(lp, (struct disklabel *)addr, 0, 0);
! 347:
! 348: case DIOCWDINFO:
! 349: if ((flag & FWRITE) == 0)
! 350: error = EBADF;
! 351: else {
! 352: sc->sc_wlabel = 1;
! 353: error = writedisklabel(dev, hpstrategy, lp, 0);
! 354: sc->sc_wlabel = 0;
! 355: }
! 356: return error;
! 357: case DIOCWLABEL:
! 358: if ((flag & FWRITE) == 0)
! 359: return EBADF;
! 360: sc->sc_wlabel = 1;
! 361: break;
! 362:
! 363: default:
! 364: printf("hpioctl: command %x\n", (unsigned int)cmd);
! 365: return ENOTTY;
! 366: }
! 367: return 0;
! 368: }
! 369:
! 370: /*
! 371: * Called when a transfer is finished. Check if transfer went OK,
! 372: * Return info about what-to-do-now.
! 373: */
! 374: enum xfer_action
! 375: hpfinish(md, mbasr, attn)
! 376: struct mba_device *md;
! 377: int mbasr, *attn;
! 378: {
! 379: struct hp_softc *sc = md->md_softc;
! 380: struct buf *bp = BUFQ_FIRST(&md->md_q);
! 381: volatile struct mba_regs *mr = md->md_mba->sc_mbareg;
! 382: volatile struct hp_regs *hr = (void *)&mr->mba_md[DISKUNIT(bp->b_dev)];
! 383: int er1, er2;
! 384: volatile int bc; /* to get GCC read whole longword */
! 385: unsigned byte;
! 386:
! 387: er1 = hr->hp_er1 & HPMASK;
! 388: er2 = hr->hp_er2 & HPMASK;
! 389: hr->hp_er1 = hr->hp_er2 = 0;
! 390: hper1:
! 391: switch (ffs(er1) - 1) {
! 392: case -1:
! 393: hr->hp_er1 = 0;
! 394: goto hper2;
! 395:
! 396: case HPER1_DCK: /* Corrected? data read. Just notice. */
! 397: bc = mr->mba_bc;
! 398: byte = ~(bc >> 16);
! 399: diskerr(buf, hp_cd.cd_name, "soft ecc", LOG_PRINTF,
! 400: btodb(bp->b_bcount - byte), sc->sc_disk.dk_label);
! 401: er1 &= ~(1<<HPER1_DCK);
! 402: er1 &= HPMASK;
! 403: break;
! 404:
! 405: default:
! 406: printf("drive error :%s er1 %x er2 %x\n",
! 407: sc->sc_dev.dv_xname, er1, er2);
! 408: hr->hp_er1 = hr->hp_er2 = 0;
! 409: goto hper2;
! 410: }
! 411: goto hper1;
! 412:
! 413: hper2:
! 414: mbasr &= ~(MBASR_DTBUSY|MBASR_DTCMP|MBASR_ATTN);
! 415: if (mbasr)
! 416: printf("massbuss error :%s %x\n",
! 417: sc->sc_dev.dv_xname, mbasr);
! 418:
! 419: BUFQ_FIRST(&md->md_q)->b_resid = 0;
! 420: disk_unbusy(&sc->sc_disk, BUFQ_FIRST(&md->md_q)->b_bcount,
! 421: (BUFQ_FIRST(&md->md_q)->b_flags & B_READ));
! 422: return XFER_FINISH;
! 423: }
! 424:
! 425: /*
! 426: * Non-data transfer interrupt; like volume change.
! 427: */
! 428: int
! 429: hpattn(md)
! 430: struct mba_device *md;
! 431: {
! 432: struct hp_softc *sc = md->md_softc;
! 433: struct mba_softc *ms = (void *)sc->sc_dev.dv_parent;
! 434: struct mba_regs *mr = ms->sc_mbareg;
! 435: struct hp_regs *hr = (void *)&mr->mba_md[sc->sc_dev.dv_unit];
! 436: int er1, er2;
! 437:
! 438: er1 = hr->hp_er1 & HPMASK;
! 439: er2 = hr->hp_er2 & HPMASK;
! 440:
! 441: printf("%s: Attention! er1 %x er2 %x\n",
! 442: sc->sc_dev.dv_xname, er1, er2);
! 443: return 0;
! 444: }
! 445:
! 446:
! 447: daddr64_t
! 448: hpsize(dev)
! 449: dev_t dev;
! 450: {
! 451: int size, unit = DISKUNIT(dev);
! 452: struct hp_softc *sc;
! 453:
! 454: if (unit >= hp_cd.cd_ndevs || hp_cd.cd_devs[unit] == 0)
! 455: return -1;
! 456:
! 457: sc = hp_cd.cd_devs[unit];
! 458: size = DL_GETPSIZE(&sc->sc_disk.dk_label->d_partitions[DISKPART(dev)]) *
! 459: (sc->sc_disk.dk_label->d_secsize / DEV_BSIZE);
! 460:
! 461: return size;
! 462: }
! 463:
! 464: int
! 465: hpdump(dev, a1, a2, size)
! 466: dev_t dev;
! 467: daddr64_t a1;
! 468: caddr_t a2;
! 469: size_t size;
! 470: {
! 471: printf("hpdump: Not implemented yet.\n");
! 472: return 0;
! 473: }
! 474:
! 475: int
! 476: hpread(dev, uio)
! 477: dev_t dev;
! 478: struct uio *uio;
! 479: {
! 480: return (physio(hpstrategy, NULL, dev, B_READ, minphys, uio));
! 481: }
! 482:
! 483: int
! 484: hpwrite(dev, uio)
! 485: dev_t dev;
! 486: struct uio *uio;
! 487: {
! 488: return (physio(hpstrategy, NULL, dev, B_WRITE, minphys, uio));
! 489: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to hp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / mba