![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev|
Return to sd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev |
1.1 ! root 1: /* ! 2: * Copyright (c) 1990 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Van Jacobson of Lawrence Berkeley Laboratory. ! 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: * @(#)sd.c 7.2 (Berkeley) 5/15/90 ! 24: */ ! 25: ! 26: /* ! 27: * SCSI CCS (Command Command Set) disk driver. ! 28: */ ! 29: #include "sd.h" ! 30: #if NSD > 0 ! 31: ! 32: #ifndef lint ! 33: static char rcsid[] = "$Header: sd.c,v 1.5 90/01/10 16:06:12 mike Locked $"; ! 34: #endif ! 35: ! 36: #include "param.h" ! 37: #include "systm.h" ! 38: #include "buf.h" ! 39: #include "errno.h" ! 40: #include "dkstat.h" ! 41: #include "disklabel.h" ! 42: #include "device.h" ! 43: #include "malloc.h" ! 44: #include "scsireg.h" ! 45: ! 46: #include "user.h" ! 47: #include "proc.h" ! 48: #include "uio.h" ! 49: ! 50: extern int scsi_test_unit_rdy(); ! 51: extern int scsi_request_sense(); ! 52: extern int scsi_inquiry(); ! 53: extern int scsi_read_capacity(); ! 54: extern int scsi_tt_write(); ! 55: extern int scsireq(); ! 56: extern int scsiustart(); ! 57: extern int scsigo(); ! 58: extern void scsifree(); ! 59: extern void scsireset(); ! 60: ! 61: extern void printf(); ! 62: extern void bcopy(); ! 63: extern void disksort(); ! 64: extern int splbio(); ! 65: extern void splx(); ! 66: extern void biodone(); ! 67: extern int physio(); ! 68: extern void TBIS(); ! 69: ! 70: int sdinit(); ! 71: void sdstrategy(), sdstart(), sdustart(), sdgo(), sdintr(); ! 72: ! 73: struct driver sddriver = { ! 74: sdinit, "sd", (int (*)())sdstart, (int (*)())sdgo, (int (*)())sdintr, ! 75: }; ! 76: ! 77: struct size { ! 78: u_long strtblk; ! 79: u_long endblk; ! 80: int nblocks; ! 81: }; ! 82: ! 83: struct sdinfo { ! 84: struct size part[8]; ! 85: }; ! 86: ! 87: /* ! 88: * since the SCSI standard tends to hide the disk structure, we define ! 89: * partitions in terms of DEV_BSIZE blocks. The default partition table ! 90: * (for an unlabeled disk) reserves 512K for a boot area, has an 8 meg ! 91: * root and 32 meg of swap. The rest of the space on the drive goes in ! 92: * the G partition. As usual, the C partition covers the entire disk ! 93: * (including the boot area). ! 94: */ ! 95: struct sdinfo sddefaultpart = { ! 96: 1024, 17408, 16384 , /* A */ ! 97: 17408, 82944, 65536 , /* B */ ! 98: 0, 0, 0 , /* C */ ! 99: 17408, 115712, 98304 , /* D */ ! 100: 115712, 218112, 102400 , /* E */ ! 101: 218112, 0, 0 , /* F */ ! 102: 82944, 0, 0 , /* G */ ! 103: 115712, 0, 0 , /* H */ ! 104: }; ! 105: ! 106: struct sd_softc { ! 107: struct hp_device *sc_hd; ! 108: struct devqueue sc_dq; ! 109: int sc_format_pid; /* process using "format" mode */ ! 110: short sc_flags; ! 111: short sc_type; /* drive type */ ! 112: short sc_punit; /* physical unit (scsi lun) */ ! 113: u_short sc_bshift; /* convert device blocks to DEV_BSIZE blks */ ! 114: u_int sc_blks; /* number of blocks on device */ ! 115: int sc_blksize; /* device block size in bytes */ ! 116: u_int sc_wpms; /* average xfer rate in 16 bit wds/sec. */ ! 117: struct sdinfo sc_info; /* drive partition table & label info */ ! 118: } sd_softc[NSD]; ! 119: ! 120: /* sc_flags values */ ! 121: #define SDF_ALIVE 0x1 ! 122: ! 123: #ifdef DEBUG ! 124: int sddebug = 1; ! 125: #define SDB_ERROR 0x01 ! 126: #define SDB_PARTIAL 0x02 ! 127: #endif ! 128: ! 129: struct sdstats { ! 130: long sdresets; ! 131: long sdtransfers; ! 132: long sdpartials; ! 133: } sdstats[NSD]; ! 134: ! 135: struct buf sdtab[NSD]; ! 136: struct buf sdbuf[NSD]; ! 137: struct scsi_fmt_cdb sdcmd[NSD]; ! 138: struct scsi_fmt_sense sdsense[NSD]; ! 139: ! 140: static struct scsi_fmt_cdb sd_read_cmd = { 10, CMD_READ_EXT }; ! 141: static struct scsi_fmt_cdb sd_write_cmd = { 10, CMD_WRITE_EXT }; ! 142: ! 143: #define sdunit(x) ((minor(x) >> 3) & 0x7) ! 144: #define sdpart(x) (minor(x) & 0x7) ! 145: #define sdpunit(x) ((x) & 7) ! 146: #define b_cylin b_resid ! 147: #define SDRETRY 2 ! 148: ! 149: /* ! 150: * Table of scsi commands users are allowed to access via "format" ! 151: * mode. 0 means not legal. 1 means "immediate" (doesn't need dma). ! 152: * -1 means needs dma and/or wait for intr. ! 153: */ ! 154: static char legal_cmds[256] = { ! 155: /***** 0 1 2 3 4 5 6 7 8 9 A B C D E F */ ! 156: /*00*/ 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 157: /*10*/ 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, ! 158: /*20*/ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 159: /*30*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 160: /*40*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 161: /*50*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 162: /*60*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 163: /*70*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 164: /*80*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 165: /*90*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 166: /*a0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 167: /*b0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 168: /*c0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 169: /*d0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 170: /*e0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 171: /*f0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 172: }; ! 173: ! 174: static struct scsi_inquiry inqbuf; ! 175: static struct scsi_fmt_cdb inq = { ! 176: 6, ! 177: CMD_INQUIRY, 0, 0, 0, sizeof(inqbuf), 0 ! 178: }; ! 179: ! 180: static u_char capbuf[8]; ! 181: struct scsi_fmt_cdb cap = { ! 182: 10, ! 183: CMD_READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 ! 184: }; ! 185: ! 186: static int ! 187: sdident(sc, hd) ! 188: struct sd_softc *sc; ! 189: struct hp_device *hd; ! 190: { ! 191: int unit; ! 192: register int ctlr, slave; ! 193: register int i; ! 194: register int tries = 10; ! 195: ! 196: ctlr = hd->hp_ctlr; ! 197: slave = hd->hp_slave; ! 198: unit = sc->sc_punit; ! 199: ! 200: /* ! 201: * See if unit exists and is a disk then read block size & nblocks. ! 202: */ ! 203: while ((i = scsi_test_unit_rdy(ctlr, slave, unit)) != 0) { ! 204: if (i == -1 || --tries < 0) ! 205: /* doesn't exist or not a CCS device */ ! 206: return (-1); ! 207: if (i == STS_CHECKCOND) { ! 208: u_char sensebuf[128]; ! 209: struct scsi_xsense *sp = (struct scsi_xsense *)sensebuf; ! 210: ! 211: scsi_request_sense(ctlr, slave, unit, sensebuf, ! 212: sizeof(sensebuf)); ! 213: if (sp->class == 7 && sp->key == 6) ! 214: /* drive doing an RTZ -- give it a while */ ! 215: DELAY(1000000); ! 216: } ! 217: DELAY(1000); ! 218: } ! 219: if (scsi_immed_command(ctlr, slave, unit, &inq, (u_char *)&inqbuf, ! 220: sizeof(inqbuf), B_READ) || ! 221: scsi_immed_command(ctlr, slave, unit, &cap, (u_char *)&capbuf, ! 222: sizeof(capbuf), B_READ)) ! 223: /* doesn't exist or not a CCS device */ ! 224: return (-1); ! 225: ! 226: switch (inqbuf.type) { ! 227: case 0: /* disk */ ! 228: case 4: /* WORM */ ! 229: case 5: /* CD-ROM */ ! 230: case 7: /* Magneto-optical */ ! 231: break; ! 232: default: /* not a disk */ ! 233: return (-1); ! 234: } ! 235: sc->sc_blks = *(u_int *)&capbuf[0]; ! 236: sc->sc_blksize = *(int *)&capbuf[4]; ! 237: ! 238: if (inqbuf.version != 1) ! 239: printf("sd%d: type 0x%x, qual 0x%x, ver %d", hd->hp_unit, ! 240: inqbuf.type, inqbuf.qual, inqbuf.version); ! 241: else { ! 242: char idstr[32]; ! 243: ! 244: bcopy((caddr_t)&inqbuf.vendor_id, (caddr_t)idstr, 28); ! 245: for (i = 27; i > 23; --i) ! 246: if (idstr[i] != ' ') ! 247: break; ! 248: idstr[i+1] = 0; ! 249: for (i = 23; i > 7; --i) ! 250: if (idstr[i] != ' ') ! 251: break; ! 252: idstr[i+1] = 0; ! 253: for (i = 7; i >= 0; --i) ! 254: if (idstr[i] != ' ') ! 255: break; ! 256: idstr[i+1] = 0; ! 257: printf("sd%d: %s %s rev %s", hd->hp_unit, idstr, &idstr[8], ! 258: &idstr[24]); ! 259: } ! 260: printf(", %d %d byte blocks\n", sc->sc_blks, sc->sc_blksize); ! 261: if (sc->sc_blksize != DEV_BSIZE) { ! 262: if (sc->sc_blksize < DEV_BSIZE) { ! 263: printf("sd%d: need %d byte blocks - drive ignored\n", ! 264: unit, DEV_BSIZE); ! 265: return (-1); ! 266: } ! 267: for (i = sc->sc_blksize; i > DEV_BSIZE; i >>= 1) ! 268: ++sc->sc_bshift; ! 269: sc->sc_blks <<= sc->sc_bshift; ! 270: } ! 271: sc->sc_wpms = 32 * (60 * DEV_BSIZE / 2); /* XXX */ ! 272: return(inqbuf.type); ! 273: } ! 274: ! 275: int ! 276: sdinit(hd) ! 277: register struct hp_device *hd; ! 278: { ! 279: register struct sd_softc *sc = &sd_softc[hd->hp_unit]; ! 280: ! 281: sc->sc_hd = hd; ! 282: sc->sc_punit = sdpunit(hd->hp_flags); ! 283: sc->sc_type = sdident(sc, hd); ! 284: if (sc->sc_type < 0) ! 285: return(0); ! 286: sc->sc_dq.dq_ctlr = hd->hp_ctlr; ! 287: sc->sc_dq.dq_unit = hd->hp_unit; ! 288: sc->sc_dq.dq_slave = hd->hp_slave; ! 289: sc->sc_dq.dq_driver = &sddriver; ! 290: ! 291: /* ! 292: * If we don't have a disk label, build a default partition ! 293: * table with 'standard' size root & swap and everything else ! 294: * in the G partition. ! 295: */ ! 296: sc->sc_info = sddefaultpart; ! 297: /* C gets everything */ ! 298: sc->sc_info.part[2].nblocks = sc->sc_blks; ! 299: sc->sc_info.part[2].endblk = sc->sc_blks; ! 300: /* G gets from end of B to end of disk */ ! 301: sc->sc_info.part[6].nblocks = sc->sc_blks - sc->sc_info.part[1].endblk; ! 302: sc->sc_info.part[6].endblk = sc->sc_blks; ! 303: /* ! 304: * We also define the D, E and F paritions as an alternative to ! 305: * B and G. D is 48Mb, starts after A and is intended for swapping. ! 306: * E is 50Mb, starts after D and is intended for /usr. F starts ! 307: * after E and is what ever is left. ! 308: */ ! 309: if (sc->sc_blks >= sc->sc_info.part[4].endblk) { ! 310: sc->sc_info.part[5].nblocks = ! 311: sc->sc_blks - sc->sc_info.part[4].endblk; ! 312: sc->sc_info.part[5].endblk = sc->sc_blks; ! 313: } else { ! 314: sc->sc_info.part[5].strtblk = 0; ! 315: sc->sc_info.part[3] = sc->sc_info.part[5]; ! 316: sc->sc_info.part[4] = sc->sc_info.part[5]; ! 317: } ! 318: /* ! 319: * H is a single partition alternative to E and F. ! 320: */ ! 321: if (sc->sc_blks >= sc->sc_info.part[3].endblk) { ! 322: sc->sc_info.part[7].nblocks = ! 323: sc->sc_blks - sc->sc_info.part[3].endblk; ! 324: sc->sc_info.part[7].endblk = sc->sc_blks; ! 325: } else { ! 326: sc->sc_info.part[7].strtblk = 0; ! 327: } ! 328: ! 329: sc->sc_flags = SDF_ALIVE; ! 330: return(1); ! 331: } ! 332: ! 333: void ! 334: sdreset(sc, hd) ! 335: register struct sd_softc *sc; ! 336: register struct hp_device *hd; ! 337: { ! 338: sdstats[hd->hp_unit].sdresets++; ! 339: } ! 340: ! 341: int ! 342: sdopen(dev, flags) ! 343: dev_t dev; ! 344: int flags; ! 345: { ! 346: register int unit = sdunit(dev); ! 347: register struct sd_softc *sc = &sd_softc[unit]; ! 348: ! 349: if (unit >= NSD) ! 350: return(ENXIO); ! 351: if ((sc->sc_flags & SDF_ALIVE) == 0 && suser(u.u_cred, &u.u_acflag)) ! 352: return(ENXIO); ! 353: ! 354: if (sc->sc_hd->hp_dk >= 0) ! 355: dk_wpms[sc->sc_hd->hp_dk] = sc->sc_wpms; ! 356: return(0); ! 357: } ! 358: ! 359: /* ! 360: * This routine is called for partial block transfers and non-aligned ! 361: * transfers (the latter only being possible on devices with a block size ! 362: * larger than DEV_BSIZE). The operation is performed in three steps ! 363: * using a locally allocated buffer: ! 364: * 1. transfer any initial partial block ! 365: * 2. transfer full blocks ! 366: * 3. transfer any final partial block ! 367: */ ! 368: static void ! 369: sdlblkstrat(bp, bsize) ! 370: register struct buf *bp; ! 371: register int bsize; ! 372: { ! 373: register struct buf *cbp = (struct buf *)malloc(sizeof(struct buf), ! 374: M_DEVBUF, M_WAITOK); ! 375: caddr_t cbuf = (caddr_t)malloc(bsize, M_DEVBUF, M_WAITOK); ! 376: register int bn, resid; ! 377: register caddr_t addr; ! 378: ! 379: bzero((caddr_t)cbp, sizeof(*cbp)); ! 380: cbp->b_proc = u.u_procp; ! 381: cbp->b_dev = bp->b_dev; ! 382: bn = bp->b_blkno; ! 383: resid = bp->b_bcount; ! 384: addr = bp->b_un.b_addr; ! 385: #ifdef DEBUG ! 386: if (sddebug & SDB_PARTIAL) ! 387: printf("sdlblkstrat: bp %x flags %x bn %x resid %x addr %x\n", ! 388: bp, bp->b_flags, bn, resid, addr); ! 389: #endif ! 390: ! 391: while (resid > 0) { ! 392: register int boff = dbtob(bn) & (bsize - 1); ! 393: register int count; ! 394: ! 395: if (boff || resid < bsize) { ! 396: sdstats[sdunit(bp->b_dev)].sdpartials++; ! 397: count = MIN(resid, bsize - boff); ! 398: cbp->b_flags = B_BUSY | B_PHYS | B_READ; ! 399: cbp->b_blkno = bn - btodb(boff); ! 400: cbp->b_un.b_addr = cbuf; ! 401: cbp->b_bcount = bsize; ! 402: #ifdef DEBUG ! 403: if (sddebug & SDB_PARTIAL) ! 404: printf(" readahead: bn %x cnt %x off %x addr %x\n", ! 405: cbp->b_blkno, count, boff, addr); ! 406: #endif ! 407: sdstrategy(cbp); ! 408: biowait(cbp); ! 409: if (cbp->b_flags & B_ERROR) { ! 410: bp->b_flags |= B_ERROR; ! 411: bp->b_error = cbp->b_error; ! 412: break; ! 413: } ! 414: if (bp->b_flags & B_READ) { ! 415: bcopy(&cbuf[boff], addr, count); ! 416: goto done; ! 417: } ! 418: bcopy(addr, &cbuf[boff], count); ! 419: #ifdef DEBUG ! 420: if (sddebug & SDB_PARTIAL) ! 421: printf(" writeback: bn %x cnt %x off %x addr %x\n", ! 422: cbp->b_blkno, count, boff, addr); ! 423: #endif ! 424: } else { ! 425: count = resid & ~(bsize - 1); ! 426: cbp->b_blkno = bn; ! 427: cbp->b_un.b_addr = addr; ! 428: cbp->b_bcount = count; ! 429: #ifdef DEBUG ! 430: if (sddebug & SDB_PARTIAL) ! 431: printf(" fulltrans: bn %x cnt %x addr %x\n", ! 432: cbp->b_blkno, count, addr); ! 433: #endif ! 434: } ! 435: cbp->b_flags = B_BUSY | B_PHYS | (bp->b_flags & B_READ); ! 436: sdstrategy(cbp); ! 437: biowait(cbp); ! 438: if (cbp->b_flags & B_ERROR) { ! 439: bp->b_flags |= B_ERROR; ! 440: bp->b_error = cbp->b_error; ! 441: break; ! 442: } ! 443: done: ! 444: bn += btodb(count); ! 445: resid -= count; ! 446: addr += count; ! 447: #ifdef DEBUG ! 448: if (sddebug & SDB_PARTIAL) ! 449: printf(" done: bn %x resid %x addr %x\n", ! 450: bn, resid, addr); ! 451: #endif ! 452: } ! 453: free(cbuf, M_DEVBUF); ! 454: free(cbp, M_DEVBUF); ! 455: } ! 456: ! 457: void ! 458: sdstrategy(bp) ! 459: register struct buf *bp; ! 460: { ! 461: register int part = sdpart(bp->b_dev); ! 462: register int unit = sdunit(bp->b_dev); ! 463: register int bn, sz; ! 464: register struct sd_softc *sc = &sd_softc[unit]; ! 465: register struct buf *dp = &sdtab[unit]; ! 466: register int s; ! 467: ! 468: if (sc->sc_format_pid) { ! 469: if (sc->sc_format_pid != u.u_procp->p_pid) { ! 470: bp->b_error = EPERM; ! 471: goto bad; ! 472: } ! 473: bp->b_cylin = 0; ! 474: } else { ! 475: bn = bp->b_blkno; ! 476: sz = (bp->b_bcount + (DEV_BSIZE - 1)) >> DEV_BSHIFT; ! 477: if (bn < 0 || bn + sz > sc->sc_info.part[part].nblocks) { ! 478: if (bn == sc->sc_info.part[part].nblocks) { ! 479: bp->b_resid = bp->b_bcount; ! 480: goto done; ! 481: } ! 482: bp->b_error = EINVAL; ! 483: goto bad; ! 484: } ! 485: /* ! 486: * Non-aligned or partial-block transfers handled specially. ! 487: */ ! 488: s = sc->sc_blksize - 1; ! 489: if ((dbtob(bn) & s) || (bp->b_bcount & s)) { ! 490: sdlblkstrat(bp, sc->sc_blksize); ! 491: goto done; ! 492: } ! 493: bp->b_cylin = (bn + sc->sc_info.part[part].strtblk) >> ! 494: sc->sc_bshift; ! 495: } ! 496: s = splbio(); ! 497: disksort(dp, bp); ! 498: if (dp->b_active == 0) { ! 499: dp->b_active = 1; ! 500: sdustart(unit); ! 501: } ! 502: splx(s); ! 503: return; ! 504: bad: ! 505: bp->b_flags |= B_ERROR; ! 506: done: ! 507: iodone(bp); ! 508: } ! 509: ! 510: void ! 511: sdustart(unit) ! 512: register int unit; ! 513: { ! 514: if (scsireq(&sd_softc[unit].sc_dq)) ! 515: sdstart(unit); ! 516: } ! 517: ! 518: static void ! 519: sderror(unit, sc, hp, stat) ! 520: int unit, stat; ! 521: register struct sd_softc *sc; ! 522: register struct hp_device *hp; ! 523: { ! 524: sdsense[unit].status = stat; ! 525: if (stat & STS_CHECKCOND) { ! 526: struct scsi_xsense *sp; ! 527: ! 528: scsi_request_sense(hp->hp_ctlr, hp->hp_slave, ! 529: sc->sc_punit, sdsense[unit].sense, ! 530: sizeof(sdsense[unit].sense)); ! 531: sp = (struct scsi_xsense *)sdsense[unit].sense; ! 532: printf("sd%d: scsi sense class %d, code %d", unit, ! 533: sp->class, sp->code); ! 534: if (sp->class == 7) { ! 535: printf(", key %d", sp->key); ! 536: if (sp->valid) ! 537: printf(", blk %d", *(int *)&sp->info1); ! 538: } ! 539: printf("\n"); ! 540: } ! 541: } ! 542: ! 543: static void ! 544: sdfinish(unit, sc, bp) ! 545: int unit; ! 546: register struct sd_softc *sc; ! 547: register struct buf *bp; ! 548: { ! 549: sdtab[unit].b_errcnt = 0; ! 550: sdtab[unit].b_actf = bp->b_actf; ! 551: bp->b_resid = 0; ! 552: iodone(bp); ! 553: scsifree(&sc->sc_dq); ! 554: if (sdtab[unit].b_actf) ! 555: sdustart(unit); ! 556: else ! 557: sdtab[unit].b_active = 0; ! 558: } ! 559: ! 560: void ! 561: sdstart(unit) ! 562: register int unit; ! 563: { ! 564: register struct sd_softc *sc = &sd_softc[unit]; ! 565: register struct hp_device *hp = sc->sc_hd; ! 566: ! 567: /* ! 568: * we have the SCSI bus -- in format mode, we may or may not need dma ! 569: * so check now. ! 570: */ ! 571: if (sc->sc_format_pid && legal_cmds[sdcmd[unit].cdb[0]] > 0) { ! 572: register struct buf *bp = sdtab[unit].b_actf; ! 573: register int sts; ! 574: ! 575: sts = scsi_immed_command(hp->hp_ctlr, hp->hp_slave, ! 576: sc->sc_punit, &sdcmd[unit], ! 577: bp->b_un.b_addr, bp->b_bcount, ! 578: bp->b_flags & B_READ); ! 579: sdsense[unit].status = sts; ! 580: if (sts & 0xfe) { ! 581: sderror(unit, sc, hp, sts); ! 582: bp->b_flags |= B_ERROR; ! 583: bp->b_error = EIO; ! 584: } ! 585: sdfinish(unit, sc, bp); ! 586: ! 587: } else if (scsiustart(hp->hp_ctlr)) ! 588: sdgo(unit); ! 589: } ! 590: ! 591: void ! 592: sdgo(unit) ! 593: register int unit; ! 594: { ! 595: register struct sd_softc *sc = &sd_softc[unit]; ! 596: register struct hp_device *hp = sc->sc_hd; ! 597: register struct buf *bp = sdtab[unit].b_actf; ! 598: register int pad; ! 599: register struct scsi_fmt_cdb *cmd; ! 600: ! 601: if (sc->sc_format_pid) { ! 602: cmd = &sdcmd[unit]; ! 603: pad = 0; ! 604: } else { ! 605: cmd = bp->b_flags & B_READ? &sd_read_cmd : &sd_write_cmd; ! 606: *(int *)(&cmd->cdb[2]) = bp->b_cylin; ! 607: pad = howmany(bp->b_bcount, sc->sc_blksize); ! 608: *(u_short *)(&cmd->cdb[7]) = pad; ! 609: pad = (bp->b_bcount & (sc->sc_blksize - 1)) != 0; ! 610: #ifdef DEBUG ! 611: if (pad) ! 612: printf("sd%d: partial block xfer -- %x bytes\n", ! 613: unit, bp->b_bcount); ! 614: #endif ! 615: sdstats[unit].sdtransfers++; ! 616: } ! 617: if (scsigo(hp->hp_ctlr, hp->hp_slave, sc->sc_punit, bp, cmd, pad) == 0) { ! 618: if (hp->hp_dk >= 0) { ! 619: dk_busy |= 1 << hp->hp_dk; ! 620: ++dk_seek[hp->hp_dk]; ! 621: ++dk_xfer[hp->hp_dk]; ! 622: dk_wds[hp->hp_dk] += bp->b_bcount >> 6; ! 623: } ! 624: return; ! 625: } ! 626: #ifdef DEBUG ! 627: if (sddebug & SDB_ERROR) ! 628: printf("sd%d: sdstart: %s adr %d blk %d len %d ecnt %d\n", ! 629: unit, bp->b_flags & B_READ? "read" : "write", ! 630: bp->b_un.b_addr, bp->b_cylin, bp->b_bcount, ! 631: sdtab[unit].b_errcnt); ! 632: #endif ! 633: bp->b_flags |= B_ERROR; ! 634: bp->b_error = EIO; ! 635: sdfinish(unit, sc, bp); ! 636: } ! 637: ! 638: void ! 639: sdintr(unit, stat) ! 640: register int unit; ! 641: int stat; ! 642: { ! 643: register struct sd_softc *sc = &sd_softc[unit]; ! 644: register struct buf *bp = sdtab[unit].b_actf; ! 645: register struct hp_device *hp = sc->sc_hd; ! 646: ! 647: if (bp == NULL) { ! 648: printf("sd%d: bp == NULL\n", unit); ! 649: return; ! 650: } ! 651: if (hp->hp_dk >= 0) ! 652: dk_busy &=~ (1 << hp->hp_dk); ! 653: if (stat) { ! 654: #ifdef DEBUG ! 655: if (sddebug & SDB_ERROR) ! 656: printf("sd%d: sdintr: bad scsi status 0x%x\n", ! 657: unit, stat); ! 658: #endif ! 659: sderror(unit, sc, hp, stat); ! 660: bp->b_flags |= B_ERROR; ! 661: bp->b_error = EIO; ! 662: } ! 663: sdfinish(unit, sc, bp); ! 664: } ! 665: ! 666: int ! 667: sdread(dev, uio) ! 668: dev_t dev; ! 669: struct uio *uio; ! 670: { ! 671: register int unit = sdunit(dev); ! 672: register int pid; ! 673: ! 674: if ((pid = sd_softc[unit].sc_format_pid) && pid != u.u_procp->p_pid) ! 675: return (EPERM); ! 676: ! 677: return(physio(sdstrategy, &sdbuf[unit], dev, B_READ, minphys, uio)); ! 678: } ! 679: ! 680: int ! 681: sdwrite(dev, uio) ! 682: dev_t dev; ! 683: struct uio *uio; ! 684: { ! 685: register int unit = sdunit(dev); ! 686: register int pid; ! 687: ! 688: if ((pid = sd_softc[unit].sc_format_pid) && pid != u.u_procp->p_pid) ! 689: return (EPERM); ! 690: ! 691: return(physio(sdstrategy, &sdbuf[unit], dev, B_WRITE, minphys, uio)); ! 692: } ! 693: ! 694: int ! 695: sdioctl(dev, cmd, data, flag) ! 696: dev_t dev; ! 697: int cmd; ! 698: caddr_t data; ! 699: int flag; ! 700: { ! 701: register int unit = sdunit(dev); ! 702: register struct sd_softc *sc = &sd_softc[unit]; ! 703: ! 704: switch (cmd) { ! 705: default: ! 706: return (EINVAL); ! 707: ! 708: case SDIOCSFORMAT: ! 709: /* take this device into or out of "format" mode */ ! 710: if (suser(u.u_cred, &u.u_acflag)) ! 711: return(EPERM); ! 712: ! 713: if (*(int *)data) { ! 714: if (sc->sc_format_pid) ! 715: return (EPERM); ! 716: sc->sc_format_pid = u.u_procp->p_pid; ! 717: } else ! 718: sc->sc_format_pid = 0; ! 719: return (0); ! 720: ! 721: case SDIOCGFORMAT: ! 722: /* find out who has the device in format mode */ ! 723: *(int *)data = sc->sc_format_pid; ! 724: return (0); ! 725: ! 726: case SDIOCSCSICOMMAND: ! 727: /* ! 728: * Save what user gave us as SCSI cdb to use with next ! 729: * read or write to the char device. ! 730: */ ! 731: if (sc->sc_format_pid != u.u_procp->p_pid) ! 732: return (EPERM); ! 733: if (legal_cmds[((struct scsi_fmt_cdb *)data)->cdb[0]] == 0) ! 734: return (EINVAL); ! 735: bcopy(data, (caddr_t)&sdcmd[unit], sizeof(sdcmd[0])); ! 736: return (0); ! 737: ! 738: case SDIOCSENSE: ! 739: /* ! 740: * return the SCSI sense data saved after the last ! 741: * operation that completed with "check condition" status. ! 742: */ ! 743: bcopy((caddr_t)&sdsense[unit], data, sizeof(sdsense[0])); ! 744: return (0); ! 745: ! 746: } ! 747: /*NOTREACHED*/ ! 748: } ! 749: ! 750: int ! 751: sdsize(dev) ! 752: dev_t dev; ! 753: { ! 754: register int unit = sdunit(dev); ! 755: register struct sd_softc *sc = &sd_softc[unit]; ! 756: ! 757: if (unit >= NSD || (sc->sc_flags & SDF_ALIVE) == 0) ! 758: return(-1); ! 759: ! 760: return(sc->sc_info.part[sdpart(dev)].nblocks); ! 761: } ! 762: ! 763: #include "machine/pte.h" ! 764: #include "machine/vmparam.h" ! 765: #include "../sys/vmmac.h" ! 766: ! 767: /* ! 768: * Non-interrupt driven, non-dma dump routine. ! 769: */ ! 770: int ! 771: sddump(dev) ! 772: dev_t dev; ! 773: { ! 774: int part = sdpart(dev); ! 775: int unit = sdunit(dev); ! 776: register struct sd_softc *sc = &sd_softc[unit]; ! 777: register struct hp_device *hp = sc->sc_hd; ! 778: register daddr_t baddr; ! 779: register int maddr; ! 780: register int pages, i; ! 781: int stat; ! 782: extern int lowram; ! 783: ! 784: /* ! 785: * Hmm... all vax drivers dump maxfree pages which is physmem minus ! 786: * the message buffer. Is there a reason for not dumping the ! 787: * message buffer? Savecore expects to read 'dumpsize' pages of ! 788: * dump, where dumpsys() sets dumpsize to physmem! ! 789: */ ! 790: pages = physmem; ! 791: ! 792: /* is drive ok? */ ! 793: if (unit >= NSD || (sc->sc_flags & SDF_ALIVE) == 0) ! 794: return (ENXIO); ! 795: /* dump parameters in range? */ ! 796: if (dumplo < 0 || dumplo >= sc->sc_info.part[part].nblocks) ! 797: return (EINVAL); ! 798: if (dumplo + ctod(pages) > sc->sc_info.part[part].nblocks) ! 799: pages = dtoc(sc->sc_info.part[part].nblocks - dumplo); ! 800: maddr = lowram; ! 801: baddr = dumplo + sc->sc_info.part[part].strtblk; ! 802: /* scsi bus idle? */ ! 803: if (!scsireq(&sc->sc_dq)) { ! 804: scsireset(hp->hp_ctlr); ! 805: sdreset(sc, sc->sc_hd); ! 806: printf("[ drive %d reset ] ", unit); ! 807: } ! 808: for (i = 0; i < pages; i++) { ! 809: #define NPGMB (1024*1024/NBPG) ! 810: /* print out how many Mbs we have dumped */ ! 811: if (i && (i % NPGMB) == 0) ! 812: printf("%d ", i / NPGMB); ! 813: #undef NPBMG ! 814: mapin(mmap, (u_int)vmmap, btop(maddr), PG_URKR|PG_CI|PG_V); ! 815: stat = scsi_tt_write(hp->hp_ctlr, hp->hp_slave, sc->sc_punit, ! 816: vmmap, NBPG, baddr, sc->sc_bshift); ! 817: if (stat) { ! 818: printf("sddump: scsi write error 0x%x\n", stat); ! 819: return (EIO); ! 820: } ! 821: maddr += NBPG; ! 822: baddr += ctod(1); ! 823: } ! 824: return (0); ! 825: } ! 826: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.