Annotation of sys/arch/vax/vsa/hdc9224.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: hdc9224.c,v 1.21 2007/06/20 20:13:41 miod Exp $ */
! 2: /* $NetBSD: hdc9224.c,v 1.16 2001/07/26 15:05:09 wiz Exp $ */
! 3: /*
! 4: * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
! 5: * All rights reserved.
! 6: *
! 7: * This code is derived from software contributed to Ludd by Bertram Barth.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. All advertising materials mentioning features or use of this software
! 18: * must display the following acknowledgement:
! 19: * This product includes software developed at Ludd, University of
! 20: * Lule}, Sweden and its contributors.
! 21: * 4. The name of the author may not be used to endorse or promote products
! 22: * derived from this software without specific prior written permission
! 23: *
! 24: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 25: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 26: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 27: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 28: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 29: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 30: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 31: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 32: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 33: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 34: */
! 35:
! 36: /*
! 37: * with much help from (in alphabetical order):
! 38: * Jeremy
! 39: * Roger Ivie
! 40: * Rick Macklem
! 41: * Mike Young
! 42: *
! 43: * Rewritten by Ragge 25 Jun 2000. New features:
! 44: * - Uses interrupts instead of polling to signal ready.
! 45: * - Can cooperate with the SCSI routines WRT. the DMA area.
! 46: *
! 47: * TODO:
! 48: * - Floppy support missing.
! 49: * - Bad block forwarding missing.
! 50: * - Statistics collection.
! 51: */
! 52: #undef HDDEBUG
! 53:
! 54: #include <sys/param.h>
! 55: #include <sys/systm.h>
! 56: #include <sys/kernel.h>
! 57: #include <sys/conf.h>
! 58: #include <sys/file.h>
! 59: #include <sys/stat.h>
! 60: #include <sys/ioctl.h>
! 61: #include <sys/buf.h>
! 62: #include <sys/proc.h>
! 63: #include <sys/user.h>
! 64: #include <sys/device.h>
! 65: #include <sys/disklabel.h>
! 66: #include <sys/disk.h>
! 67: #include <sys/syslog.h>
! 68: #include <sys/reboot.h>
! 69:
! 70: #include <uvm/uvm_extern.h>
! 71:
! 72: #include <ufs/ufs/dinode.h> /* For BBSIZE */
! 73: #include <ufs/ffs/fs.h>
! 74:
! 75: #include <machine/pte.h>
! 76: #include <machine/sid.h>
! 77: #include <machine/cpu.h>
! 78: #include <machine/uvax.h>
! 79: #include <machine/ka410.h>
! 80: #include <machine/vsbus.h>
! 81: #include <machine/rpb.h>
! 82: #include <machine/scb.h>
! 83:
! 84: #include <arch/vax/mscp/mscp.h> /* For DEC disk encoding */
! 85:
! 86: #include <vax/vsa/hdc9224.h>
! 87:
! 88: /*
! 89: * on-disk geometry block
! 90: */
! 91: struct hdgeom {
! 92: char mbz[10]; /* 10 bytes of zero */
! 93: long xbn_count; /* number of XBNs */
! 94: long dbn_count; /* number of DBNs */
! 95: long lbn_count; /* number of LBNs (Logical-Block-Numbers) */
! 96: long rbn_count; /* number of RBNs (Replacement-Block-Numbers) */
! 97: short nspt; /* number of sectors per track */
! 98: short ntracks; /* number of tracks */
! 99: short ncylinders; /* number of cylinders */
! 100: short precomp; /* first cylinder for write precompensation */
! 101: short reduced; /* first cylinder for reduced write current */
! 102: short seek_rate; /* seek rate or zero for buffered seeks */
! 103: short crc_eec; /* 0 if CRC, 1 if ECC is being used */
! 104: short rct; /* "replacement control table" (RCT) */
! 105: short rct_ncopies; /* number of copies of the RCT */
! 106: long media_id; /* media identifier */
! 107: short interleave; /* sector-to-sector interleave */
! 108: short headskew; /* head-to-head skew */
! 109: short cylskew; /* cylinder-to-cylinder skew */
! 110: short gap0_size; /* size of GAP 0 in the MFM format */
! 111: short gap1_size; /* size of GAP 1 in the MFM format */
! 112: short gap2_size; /* size of GAP 2 in the MFM format */
! 113: short gap3_size; /* size of GAP 3 in the MFM format */
! 114: short sync_value; /* sync value used when formatting */
! 115: char reserved[32]; /* reserved for use by the RQDX formatter */
! 116: short serial_number; /* serial number */
! 117: #if 0 /* we don't need these 412 useless bytes ... */
! 118: char fill[412-2]; /* Filler bytes to the end of the block */
! 119: short checksum; /* checksum over the XBN */
! 120: #endif
! 121: } __packed;
! 122:
! 123: /*
! 124: * Software status
! 125: */
! 126: struct hdsoftc {
! 127: struct device sc_dev; /* must be here! (pseudo-OOP:) */
! 128: struct disk sc_disk; /* disklabel etc. */
! 129: struct hdgeom sc_xbn; /* on-disk geometry information */
! 130: int sc_drive; /* physical unit number */
! 131: };
! 132:
! 133: struct hdcsoftc {
! 134: struct device sc_dev; /* must be here (pseudo-OOP:) */
! 135: struct evcount sc_intrcnt;
! 136: struct vsbus_dma sc_vd;
! 137: vaddr_t sc_regs; /* register addresses */
! 138: struct buf sc_buf_queue;
! 139: struct buf *sc_active;
! 140: struct hdc9224_UDCreg sc_creg; /* (command) registers to be written */
! 141: struct hdc9224_UDCreg sc_sreg; /* (status) registers being read */
! 142: caddr_t sc_dmabase; /* */
! 143: int sc_dmasize;
! 144: caddr_t sc_bufaddr; /* Current in-core address */
! 145: daddr64_t sc_diskblk; /* Current block on disk */
! 146: int sc_bytecnt; /* How much left to transfer */
! 147: int sc_xfer; /* Current transfer size */
! 148: int sc_retries;
! 149: volatile u_char sc_status; /* last status from interrupt */
! 150: char sc_intbit;
! 151: };
! 152:
! 153: struct hdc_attach_args {
! 154: int ha_drive;
! 155: };
! 156:
! 157: /*
! 158: * prototypes for (almost) all the internal routines
! 159: */
! 160: int hdcmatch(struct device *, void *, void *);
! 161: void hdcattach(struct device *, struct device *, void *);
! 162: int hdcprint(void *, const char *);
! 163: int hdmatch(struct device *, void *, void *);
! 164: void hdattach(struct device *, struct device *, void *);
! 165: void hdcintr(void *);
! 166: int hdc_command(struct hdcsoftc *, int);
! 167: void hd_readgeom(struct hdcsoftc *, struct hdsoftc *);
! 168: #ifdef HDDEBUG
! 169: void hdc_printgeom( struct hdgeom *);
! 170: #endif
! 171: void hdc_writeregs(struct hdcsoftc *);
! 172: void hdcstart(struct hdcsoftc *, struct buf *);
! 173: int hdc_hdselect(struct hdcsoftc *, int);
! 174: void hdmakelabel(struct disklabel *, struct hdgeom *);
! 175: void hdc_writeregs(struct hdcsoftc *);
! 176: void hdc_readregs(struct hdcsoftc *);
! 177: void hdc_qstart(void *);
! 178:
! 179: bdev_decl(hd);
! 180: cdev_decl(hd);
! 181:
! 182: const struct cfattach hdc_ca = {
! 183: sizeof(struct hdcsoftc), hdcmatch, hdcattach
! 184: };
! 185:
! 186: struct cfdriver hdc_cd = {
! 187: NULL, "hdc", DV_DULL
! 188: };
! 189:
! 190: const struct cfattach hd_ca = {
! 191: sizeof(struct hdsoftc), hdmatch, hdattach
! 192: };
! 193:
! 194: struct cfdriver hd_cd = {
! 195: NULL, "hd", DV_DISK
! 196: };
! 197:
! 198: /* At least 0.7 uS between register accesses */
! 199: static int hd_dmasize, inq = 0; /* XXX should be in softc... but only 1 ctrl */
! 200: static int u;
! 201: #define WAIT asm("movl _u,_u;movl _u,_u;movl _u,_u; movl _u,_u")
! 202:
! 203: #define HDC_WREG(x) *(volatile char *)(sc->sc_regs) = (x)
! 204: #define HDC_RREG *(volatile char *)(sc->sc_regs)
! 205: #define HDC_WCMD(x) *(volatile char *)(sc->sc_regs + 4) = (x)
! 206: #define HDC_RSTAT *(volatile char *)(sc->sc_regs + 4)
! 207:
! 208: /*
! 209: * new-config's hdcmatch() is similar to old-config's hdcprobe(),
! 210: * thus we probe for the existence of the controller and reset it.
! 211: * NB: we can't initialize the controller yet, since space for hdcsoftc
! 212: * is not yet allocated. Thus we do this in hdcattach()...
! 213: */
! 214: int
! 215: hdcmatch(struct device *parent, void *vcf, void *aux)
! 216: {
! 217: static int matched = 0;
! 218: struct vsbus_attach_args *va = aux;
! 219: volatile char *hdc_csr = (char *)va->va_addr;
! 220: int i;
! 221:
! 222: if (vax_boardtype == VAX_BTYP_49 || vax_boardtype == VAX_BTYP_46 ||
! 223: vax_boardtype == VAX_BTYP_48 || vax_boardtype == VAX_BTYP_1303)
! 224: return (0);
! 225:
! 226: /* Can only match once due to DMA setup. This should not be an issue. */
! 227: if (matched != 0)
! 228: return (0);
! 229:
! 230: hdc_csr[4] = DKC_CMD_RESET; /* reset chip */
! 231: for (i = 0; i < 1000; i++) {
! 232: DELAY(1000);
! 233: if (hdc_csr[4] & DKC_ST_DONE)
! 234: break;
! 235: }
! 236: if (i == 100)
! 237: return 0; /* No response to reset */
! 238:
! 239: hdc_csr[4] = DKC_CMD_SETREGPTR|UDC_TERM;
! 240: WAIT;
! 241: hdc_csr[0] = UDC_TC_CRCPRE|UDC_TC_INTDONE;
! 242: WAIT;
! 243: hdc_csr[4] = DKC_CMD_DRDESELECT; /* Should be harmless */
! 244: DELAY(1000);
! 245: return (matched = 1);
! 246: }
! 247:
! 248: int
! 249: hdcprint(void *aux, const char *pnp)
! 250: {
! 251: struct hdc_attach_args *ha = aux;
! 252:
! 253: if (pnp != NULL)
! 254: printf("%s at %s drive %d",
! 255: ha->ha_drive == 2 ? "ry" : "hd", pnp, ha->ha_drive);
! 256:
! 257: return (UNCONF);
! 258: }
! 259:
! 260: /*
! 261: * hdc_attach() probes for all possible devices
! 262: */
! 263: void
! 264: hdcattach(struct device *parent, struct device *self, void *aux)
! 265: {
! 266: struct vsbus_attach_args *va = aux;
! 267: struct hdcsoftc *sc = (void *)self;
! 268: struct hdc_attach_args ha;
! 269: int status, i;
! 270:
! 271: u = 0; /* !!! - GCC */
! 272:
! 273: printf("\n");
! 274:
! 275: /*
! 276: * Get interrupt vector, enable instrumentation.
! 277: */
! 278: scb_vecalloc(va->va_cvec, hdcintr, sc, SCB_ISTACK, &sc->sc_intrcnt);
! 279: evcount_attach(&sc->sc_intrcnt, self->dv_xname, (void *)va->va_cvec,
! 280: &evcount_intr);
! 281:
! 282: sc->sc_regs = vax_map_physmem(va->va_paddr, 1);
! 283: sc->sc_dmabase = (caddr_t)va->va_dmaaddr;
! 284: sc->sc_dmasize = va->va_dmasize;
! 285: sc->sc_intbit = va->va_maskno;
! 286: hd_dmasize = min(MAXPHYS, sc->sc_dmasize); /* Used in hd_minphys */
! 287:
! 288: sc->sc_vd.vd_go = hdc_qstart;
! 289: sc->sc_vd.vd_arg = sc;
! 290:
! 291: /*
! 292: * Reset controller.
! 293: */
! 294: HDC_WCMD(DKC_CMD_RESET);
! 295: DELAY(1000);
! 296: status = HDC_RSTAT;
! 297: if (status != (DKC_ST_DONE|DKC_TC_SUCCESS)) {
! 298: printf("%s: RESET failed, status 0x%x\n",
! 299: sc->sc_dev.dv_xname, status);
! 300: return;
! 301: }
! 302:
! 303: /*
! 304: * now probe for all possible hard drives
! 305: */
! 306: for (i = 0; i < 4; i++) {
! 307: if (i == 2) /* Floppy, needs special handling */
! 308: continue;
! 309: HDC_WCMD(DKC_CMD_DRSELECT | i);
! 310: DELAY(1000);
! 311: status = HDC_RSTAT;
! 312: ha.ha_drive = i;
! 313: if ((status & DKC_ST_TERMCOD) == DKC_TC_SUCCESS)
! 314: config_found(self, (void *)&ha, hdcprint);
! 315: }
! 316: }
! 317:
! 318: /*
! 319: * hdmatch() probes for the existence of a HD-type disk/floppy
! 320: */
! 321: int
! 322: hdmatch(parent, vcf, aux)
! 323: struct device *parent;
! 324: void *vcf;
! 325: void *aux;
! 326: {
! 327: struct hdc_attach_args *ha = aux;
! 328: struct cfdata *cf = vcf;
! 329:
! 330: if (cf->cf_loc[0] != -1 &&
! 331: cf->cf_loc[0] != ha->ha_drive)
! 332: return 0;
! 333:
! 334: if (ha->ha_drive == 2) /* Always floppy, not supported */
! 335: return 0;
! 336:
! 337: return 1;
! 338: }
! 339:
! 340: #define HDMAJOR 19
! 341:
! 342: void
! 343: hdattach(struct device *parent, struct device *self, void *aux)
! 344: {
! 345: struct hdcsoftc *sc = (void*)parent;
! 346: struct hdsoftc *hd = (void*)self;
! 347: struct hdc_attach_args *ha = aux;
! 348: struct disklabel *dl;
! 349: char *msg;
! 350:
! 351: hd->sc_drive = ha->ha_drive;
! 352: /*
! 353: * Initialize and attach the disk structure.
! 354: */
! 355: hd->sc_disk.dk_name = hd->sc_dev.dv_xname;
! 356: disk_attach(&hd->sc_disk);
! 357:
! 358: /*
! 359: * if it's not a floppy then evaluate the on-disk geometry.
! 360: * if necessary correct the label...
! 361: */
! 362: hd_readgeom(sc, hd);
! 363: disk_printtype(hd->sc_drive, hd->sc_xbn.media_id);
! 364: dl = hd->sc_disk.dk_label;
! 365: hdmakelabel(dl, &hd->sc_xbn);
! 366: msg = readdisklabel(MAKEDISKDEV(HDMAJOR, hd->sc_dev.dv_unit, RAW_PART),
! 367: hdstrategy, dl, 0);
! 368: printf("%s: %luMB, %lu sectors\n",
! 369: hd->sc_dev.dv_xname, DL_GETDSIZE(dl) / (1048576 / DEV_BSIZE),
! 370: DL_GETDSIZE(dl));
! 371: if (msg) {
! 372: /*printf("%s: %s\n", hd->sc_dev.dv_xname, msg);*/
! 373: }
! 374: #ifdef HDDEBUG
! 375: hdc_printgeom(&hd->sc_xbn);
! 376: #endif
! 377: }
! 378:
! 379: void
! 380: hdcintr(void *arg)
! 381: {
! 382: struct hdcsoftc *sc = arg;
! 383: struct buf *bp;
! 384:
! 385: sc->sc_status = HDC_RSTAT;
! 386: if (sc->sc_active == 0)
! 387: return; /* Complain? */
! 388:
! 389: if ((sc->sc_status & (DKC_ST_INTPEND | DKC_ST_DONE)) !=
! 390: (DKC_ST_INTPEND | DKC_ST_DONE))
! 391: return; /* Why spurious ints sometimes??? */
! 392:
! 393: bp = sc->sc_active;
! 394: sc->sc_active = 0;
! 395: if ((sc->sc_status & DKC_ST_TERMCOD) != DKC_TC_SUCCESS) {
! 396: int i;
! 397: u_char *g = (u_char *)&sc->sc_sreg;
! 398:
! 399: if (sc->sc_retries++ < 3) { /* Allow 3 retries */
! 400: hdcstart(sc, bp);
! 401: return;
! 402: }
! 403: printf("%s: failed, status 0x%x\n",
! 404: sc->sc_dev.dv_xname, sc->sc_status);
! 405: hdc_readregs(sc);
! 406: for (i = 0; i < 10; i++)
! 407: printf("%i: %x\n", i, g[i]);
! 408: bp->b_flags |= B_ERROR;
! 409: bp->b_error = ENXIO;
! 410: bp->b_resid = bp->b_bcount;
! 411: biodone(bp);
! 412: vsbus_dma_intr();
! 413: return;
! 414: }
! 415:
! 416: if (bp->b_flags & B_READ) {
! 417: vsbus_copytoproc(bp->b_proc, sc->sc_dmabase, sc->sc_bufaddr,
! 418: sc->sc_xfer);
! 419: }
! 420: sc->sc_diskblk += (sc->sc_xfer/DEV_BSIZE);
! 421: sc->sc_bytecnt -= sc->sc_xfer;
! 422: sc->sc_bufaddr += sc->sc_xfer;
! 423:
! 424: if (sc->sc_bytecnt == 0) { /* Finished transfer */
! 425: biodone(bp);
! 426: vsbus_dma_intr();
! 427: } else
! 428: hdcstart(sc, bp);
! 429: }
! 430:
! 431: /*
! 432: *
! 433: */
! 434: void
! 435: hdstrategy(struct buf *bp)
! 436: {
! 437: struct hdsoftc *hd;
! 438: struct hdcsoftc *sc;
! 439: struct disklabel *lp;
! 440: int unit, s;
! 441:
! 442: unit = DISKUNIT(bp->b_dev);
! 443: if (unit > hd_cd.cd_ndevs || (hd = hd_cd.cd_devs[unit]) == NULL) {
! 444: bp->b_error = ENXIO;
! 445: bp->b_flags |= B_ERROR;
! 446: goto done;
! 447: }
! 448: sc = (void *)hd->sc_dev.dv_parent;
! 449:
! 450: lp = hd->sc_disk.dk_label;
! 451: if ((bounds_check_with_label(bp, hd->sc_disk.dk_label, 1)) <= 0)
! 452: goto done;
! 453:
! 454: if (bp->b_bcount == 0)
! 455: goto done;
! 456:
! 457: s = splbio();
! 458: disksort(&sc->sc_buf_queue, bp);
! 459: if (inq == 0) {
! 460: inq = 1;
! 461: vsbus_dma_start(&sc->sc_vd);
! 462: }
! 463: splx(s);
! 464: return;
! 465:
! 466: done:
! 467: s = splbio();
! 468: biodone(bp);
! 469: splx(s);
! 470: }
! 471:
! 472: void
! 473: hdc_qstart(void *arg)
! 474: {
! 475: struct hdcsoftc *sc = arg;
! 476: struct buf *dp;
! 477:
! 478: inq = 0;
! 479:
! 480: hdcstart(sc, NULL);
! 481: dp = &sc->sc_buf_queue;
! 482: if (dp->b_actf != NULL) {
! 483: vsbus_dma_start(&sc->sc_vd); /* More to go */
! 484: inq = 1;
! 485: }
! 486: }
! 487:
! 488: void
! 489: hdcstart(struct hdcsoftc *sc, struct buf *ob)
! 490: {
! 491: struct hdc9224_UDCreg *p = &sc->sc_creg;
! 492: struct disklabel *lp;
! 493: struct hdsoftc *hd;
! 494: struct buf *dp, *bp;
! 495: int cn, sn, tn, blks;
! 496: volatile char ch;
! 497: daddr64_t bn;
! 498:
! 499: splassert(IPL_BIO);
! 500:
! 501: if (sc->sc_active)
! 502: return; /* Already doing something */
! 503:
! 504: if (ob == NULL) {
! 505: dp = &sc->sc_buf_queue;
! 506: if ((bp = dp->b_actf) == NULL)
! 507: return; /* Nothing to do */
! 508:
! 509: dp->b_actf = bp->b_actf;
! 510: sc->sc_bufaddr = bp->b_data;
! 511: sc->sc_bytecnt = bp->b_bcount;
! 512: sc->sc_retries = 0;
! 513: bp->b_resid = 0;
! 514: } else
! 515: bp = ob;
! 516:
! 517: hd = hd_cd.cd_devs[DISKUNIT(bp->b_dev)];
! 518: lp = hd->sc_disk.dk_label;
! 519: hdc_hdselect(sc, hd->sc_drive);
! 520: sc->sc_active = bp;
! 521:
! 522: if (ob == NULL) {
! 523: sc->sc_diskblk = bp->b_blkno +
! 524: DL_GETPOFFSET(&lp->d_partitions[DISKPART(bp->b_dev)]);
! 525: }
! 526: bn = sc->sc_diskblk;
! 527:
! 528: if (bn != 0) {
! 529: cn = bn / lp->d_secpercyl;
! 530: sn = bn % lp->d_secpercyl;
! 531: tn = sn / lp->d_nsectors;
! 532: sn = sn % lp->d_nsectors;
! 533: } else
! 534: cn = sn = tn = 0;
! 535:
! 536: cn++; /* first cylinder is reserved */
! 537:
! 538: bzero(p, sizeof(struct hdc9224_UDCreg));
! 539:
! 540: /*
! 541: * Tricky thing: the controller itself only increases the sector
! 542: * number, not the track or cylinder number. Therefore the driver
! 543: * is not allowed to have transfers that crosses track boundaries.
! 544: */
! 545: blks = sc->sc_bytecnt / DEV_BSIZE;
! 546: if ((sn + blks) > lp->d_nsectors)
! 547: blks = lp->d_nsectors - sn;
! 548:
! 549: p->udc_dsect = sn;
! 550: p->udc_dcyl = cn & 0xff;
! 551: p->udc_dhead = ((cn >> 4) & 0x70) | tn;
! 552: p->udc_scnt = blks;
! 553:
! 554: p->udc_rtcnt = UDC_RC_RTRYCNT;
! 555: p->udc_mode = UDC_MD_HDD;
! 556: p->udc_term = UDC_TC_CRCPRE|UDC_TC_INTDONE|UDC_TC_TDELDAT|UDC_TC_TWRFLT;
! 557: hdc_writeregs(sc);
! 558:
! 559: /* Count up vars */
! 560: sc->sc_xfer = blks * DEV_BSIZE;
! 561:
! 562: ch = HDC_RSTAT; /* Avoid pending interrupts */
! 563: WAIT;
! 564: vsbus_clrintr(sc->sc_intbit); /* Clear pending int's */
! 565:
! 566: if (bp->b_flags & B_READ) {
! 567: HDC_WCMD(DKC_CMD_READ_HDD);
! 568: } else {
! 569: vsbus_copyfromproc(bp->b_proc, sc->sc_bufaddr, sc->sc_dmabase,
! 570: sc->sc_xfer);
! 571: HDC_WCMD(DKC_CMD_WRITE_HDD);
! 572: }
! 573: }
! 574:
! 575: void
! 576: hd_readgeom(struct hdcsoftc *sc, struct hdsoftc *hd)
! 577: {
! 578: struct hdc9224_UDCreg *p = &sc->sc_creg;
! 579:
! 580: hdc_hdselect(sc, hd->sc_drive); /* select drive right now */
! 581:
! 582: bzero(p, sizeof(struct hdc9224_UDCreg));
! 583:
! 584: p->udc_scnt = 1;
! 585: p->udc_rtcnt = UDC_RC_RTRYCNT;
! 586: p->udc_mode = UDC_MD_HDD;
! 587: p->udc_term = UDC_TC_CRCPRE|UDC_TC_INTDONE|UDC_TC_TDELDAT|UDC_TC_TWPROT;
! 588: hdc_writeregs(sc);
! 589: sc->sc_status = 0;
! 590: HDC_WCMD(DKC_CMD_READ_HDD|2);
! 591: while ((sc->sc_status & DKC_ST_INTPEND) == 0)
! 592: ;
! 593: bcopy(sc->sc_dmabase, &hd->sc_xbn, sizeof(struct hdgeom));
! 594: }
! 595:
! 596: #ifdef HDDEBUG
! 597: /*
! 598: * display the contents of the on-disk geometry structure
! 599: */
! 600: void
! 601: hdc_printgeom(p)
! 602: struct hdgeom *p;
! 603: {
! 604: printf("**DiskData** XBNs: %ld, DBNs: %ld, LBNs: %ld, RBNs: %ld\n",
! 605: p->xbn_count, p->dbn_count, p->lbn_count, p->rbn_count);
! 606: printf("sec/track: %d, tracks: %d, cyl: %d, precomp/reduced: %d/%d\n",
! 607: p->nspt, p->ntracks, p->ncylinders, p->precomp, p->reduced);
! 608: printf("seek-rate: %d, crc/eec: %s, RCT: %d, RCT-copies: %d\n",
! 609: p->seek_rate, p->crc_eec?"EEC":"CRC", p->rct, p->rct_ncopies);
! 610: printf("media-ID: %lx, interleave: %d, headskew: %d, cylskew: %d\n",
! 611: p->media_id, p->interleave, p->headskew, p->cylskew);
! 612: printf("gap0: %d, gap1: %d, gap2: %d, gap3: %d, sync-value: %d\n",
! 613: p->gap0_size, p->gap1_size, p->gap2_size, p->gap3_size,
! 614: p->sync_value);
! 615: }
! 616: #endif
! 617:
! 618: /*
! 619: * Return the size of a partition, if known, or -1 if not.
! 620: */
! 621: daddr64_t
! 622: hdsize(dev_t dev)
! 623: {
! 624: struct hdsoftc *hd;
! 625: int unit = DISKUNIT(dev);
! 626: int size;
! 627:
! 628: if (unit >= hd_cd.cd_ndevs || hd_cd.cd_devs[unit] == 0)
! 629: return -1;
! 630: hd = hd_cd.cd_devs[unit];
! 631: size = DL_GETPSIZE(&hd->sc_disk.dk_label->d_partitions[DISKPART(dev)]) *
! 632: (hd->sc_disk.dk_label->d_secsize / DEV_BSIZE);
! 633:
! 634: return (size);
! 635: }
! 636:
! 637: /*
! 638: *
! 639: */
! 640: int
! 641: hdopen(dev_t dev, int flag, int fmt, struct proc *p)
! 642: {
! 643: struct hdsoftc *hd;
! 644: int unit, part;
! 645:
! 646: unit = DISKUNIT(dev);
! 647: if (unit >= hd_cd.cd_ndevs)
! 648: return ENXIO;
! 649: hd = hd_cd.cd_devs[unit];
! 650: if (hd == 0)
! 651: return ENXIO;
! 652:
! 653: part = DISKPART(dev);
! 654: if (part >= hd->sc_disk.dk_label->d_npartitions)
! 655: return ENXIO;
! 656:
! 657: switch (fmt) {
! 658: case S_IFCHR:
! 659: hd->sc_disk.dk_copenmask |= (1 << part);
! 660: break;
! 661: case S_IFBLK:
! 662: hd->sc_disk.dk_bopenmask |= (1 << part);
! 663: break;
! 664: }
! 665: hd->sc_disk.dk_openmask =
! 666: hd->sc_disk.dk_copenmask | hd->sc_disk.dk_bopenmask;
! 667:
! 668: return 0;
! 669: }
! 670:
! 671: /*
! 672: *
! 673: */
! 674: int
! 675: hdclose(dev_t dev, int flag, int fmt, struct proc *p)
! 676: {
! 677: struct hdsoftc *hd;
! 678: int part;
! 679:
! 680: hd = hd_cd.cd_devs[DISKUNIT(dev)];
! 681: part = DISKPART(dev);
! 682:
! 683: switch (fmt) {
! 684: case S_IFCHR:
! 685: hd->sc_disk.dk_copenmask &= ~(1 << part);
! 686: break;
! 687: case S_IFBLK:
! 688: hd->sc_disk.dk_bopenmask &= ~(1 << part);
! 689: break;
! 690: }
! 691: hd->sc_disk.dk_openmask =
! 692: hd->sc_disk.dk_copenmask | hd->sc_disk.dk_bopenmask;
! 693:
! 694: return (0);
! 695: }
! 696:
! 697: /*
! 698: *
! 699: */
! 700: int
! 701: hdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
! 702: {
! 703: struct hdsoftc *hd = hd_cd.cd_devs[DISKUNIT(dev)];
! 704: struct disklabel *lp = hd->sc_disk.dk_label;
! 705: int err = 0;
! 706:
! 707: switch (cmd) {
! 708: case DIOCGDINFO:
! 709: bcopy(lp, addr, sizeof (struct disklabel));
! 710: break;
! 711:
! 712: case DIOCGPART:
! 713: ((struct partinfo *)addr)->disklab = lp;
! 714: ((struct partinfo *)addr)->part =
! 715: &lp->d_partitions[DISKPART(dev)];
! 716: break;
! 717:
! 718: case DIOCWDINFO:
! 719: case DIOCSDINFO:
! 720: if ((flag & FWRITE) == 0)
! 721: return EBADF;
! 722: else
! 723: err = (cmd == DIOCSDINFO ?
! 724: setdisklabel(lp, (struct disklabel *)addr, 0) :
! 725: writedisklabel(dev, hdstrategy, lp));
! 726: break;
! 727:
! 728: case DIOCWLABEL:
! 729: if ((flag & FWRITE) == 0)
! 730: err = EBADF;
! 731: break;
! 732:
! 733: default:
! 734: err = ENOTTY;
! 735: break;
! 736: }
! 737: return err;
! 738: }
! 739:
! 740: /*
! 741: *
! 742: */
! 743: int
! 744: hdread(dev_t dev, struct uio *uio, int flag)
! 745: {
! 746: return (physio(hdstrategy, NULL, dev, B_READ, minphys, uio));
! 747: }
! 748:
! 749: /*
! 750: *
! 751: */
! 752: int
! 753: hdwrite(dev_t dev, struct uio *uio, int flag)
! 754: {
! 755: return (physio(hdstrategy, NULL, dev, B_WRITE, minphys, uio));
! 756: }
! 757:
! 758: /*
! 759: *
! 760: */
! 761: int
! 762: hddump(dev_t dev, daddr64_t daddr, caddr_t addr, size_t size)
! 763: {
! 764: return 0;
! 765: }
! 766:
! 767: /*
! 768: * we have to wait 0.7 usec between two accesses to any of the
! 769: * dkc-registers, on a VS2000 with 1 MIPS, this is roughly one
! 770: * instruction. Thus the loop-overhead will be enough...
! 771: */
! 772: void
! 773: hdc_readregs(struct hdcsoftc *sc)
! 774: {
! 775: int i;
! 776: char *p;
! 777:
! 778: HDC_WCMD(DKC_CMD_SETREGPTR);
! 779: WAIT;
! 780: p = (void *)&sc->sc_sreg;
! 781: for (i = 0; i < 10; i++) {
! 782: *p++ = HDC_RREG; /* dkc_reg auto-increments */
! 783: WAIT;
! 784: }
! 785: }
! 786:
! 787: void
! 788: hdc_writeregs(struct hdcsoftc *sc)
! 789: {
! 790: int i;
! 791: char *p;
! 792:
! 793: HDC_WCMD(DKC_CMD_SETREGPTR);
! 794: p = (void *)&sc->sc_creg;
! 795: for (i = 0; i < 10; i++) {
! 796: HDC_WREG(*p++); /* dkc_reg auto-increments */
! 797: WAIT;
! 798: }
! 799: }
! 800:
! 801: /*
! 802: * hdc_command() issues a command and polls the intreq-register
! 803: * to find when command has completed
! 804: */
! 805: int
! 806: hdc_command(struct hdcsoftc *sc, int cmd)
! 807: {
! 808: hdc_writeregs(sc); /* write the prepared registers */
! 809: HDC_WCMD(cmd);
! 810: WAIT;
! 811: return (0);
! 812: }
! 813:
! 814: int
! 815: hdc_hdselect(struct hdcsoftc *sc, int unit)
! 816: {
! 817: struct hdc9224_UDCreg *p = &sc->sc_creg;
! 818: int error;
! 819:
! 820: /*
! 821: * bring "creg" in some known-to-work state and
! 822: * select the drive with the DRIVE SELECT command.
! 823: */
! 824: bzero(p, sizeof(struct hdc9224_UDCreg));
! 825:
! 826: p->udc_rtcnt = UDC_RC_HDD_READ;
! 827: p->udc_mode = UDC_MD_HDD;
! 828: p->udc_term = UDC_TC_HDD;
! 829:
! 830: error = hdc_command(sc, DKC_CMD_DRSEL_HDD | unit);
! 831:
! 832: return (error);
! 833: }
! 834:
! 835: void
! 836: hdmakelabel(struct disklabel *dl, struct hdgeom *g)
! 837: {
! 838: int n, p = 0;
! 839:
! 840: dl->d_bbsize = BBSIZE;
! 841: dl->d_sbsize = SBSIZE;
! 842: dl->d_typename[p++] = MSCP_MID_CHAR(2, g->media_id);
! 843: dl->d_typename[p++] = MSCP_MID_CHAR(1, g->media_id);
! 844: if (MSCP_MID_ECH(0, g->media_id))
! 845: dl->d_typename[p++] = MSCP_MID_CHAR(0, g->media_id);
! 846: n = MSCP_MID_NUM(g->media_id);
! 847: if (n > 99) {
! 848: dl->d_typename[p++] = '1';
! 849: n -= 100;
! 850: }
! 851: if (n > 9) {
! 852: dl->d_typename[p++] = (n / 10) + '0';
! 853: n %= 10;
! 854: }
! 855: dl->d_typename[p++] = n + '0';
! 856: dl->d_typename[p] = 0;
! 857: dl->d_type = DTYPE_MSCP; /* XXX - what to use here??? */
! 858: dl->d_rpm = 3600;
! 859: dl->d_secsize = DEV_BSIZE;
! 860:
! 861: DL_SETDSIZE(dl, g->lbn_count);
! 862: dl->d_nsectors = g->nspt;
! 863: dl->d_ntracks = g->ntracks;
! 864: dl->d_secpercyl = dl->d_nsectors * dl->d_ntracks;
! 865: dl->d_ncylinders = DL_GETDSIZE(dl) / dl->d_secpercyl;
! 866:
! 867: dl->d_npartitions = MAXPARTITIONS;
! 868: DL_SETPSIZE(&dl->d_partitions[0], DL_GETDSIZE(dl));
! 869: DL_SETPSIZE(&dl->d_partitions[2], DL_GETDSIZE(dl));
! 870:
! 871: DL_SETPOFFSET(&dl->d_partitions[0], 0);
! 872: DL_SETPOFFSET(&dl->d_partitions[2], 0);
! 873: dl->d_interleave = dl->d_headswitch = 1;
! 874: dl->d_version = 1;
! 875: dl->d_magic = dl->d_magic2 = DISKMAGIC;
! 876: dl->d_checksum = dkcksum(dl);
! 877: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to hdc9224.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / vsa