![[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 [Net/2] / Net2 / arch / amiga / dev|
Return to sd.c CVS log | Up to [Net/2] / Net2 / arch / amiga / dev |
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 and use in source and binary forms, with or without ! 9: * modification, are permitted provided that the following conditions ! 10: * are met: ! 11: * 1. Redistributions of source code must retain the above copyright ! 12: * notice, this list of conditions and the following disclaimer. ! 13: * 2. Redistributions in binary form must reproduce the above copyright ! 14: * notice, this list of conditions and the following disclaimer in the ! 15: * documentation and/or other materials provided with the distribution. ! 16: * 3. All advertising materials mentioning features or use of this software ! 17: * must display the following acknowledgement: ! 18: * This product includes software developed by the University of ! 19: * California, Berkeley and its contributors. ! 20: * 4. Neither the name of the University nor the names of its contributors ! 21: * may be used to endorse or promote products derived from this software ! 22: * without specific prior written permission. ! 23: * ! 24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 34: * SUCH DAMAGE. ! 35: * ! 36: * @(#)sd.c 7.8 (Berkeley) 6/9/91 ! 37: */ ! 38: ! 39: /* ! 40: * SCSI CCS (Command Command Set) disk driver. ! 41: */ ! 42: #include "sd.h" ! 43: #if NSD > 0 ! 44: ! 45: #ifndef lint ! 46: static char rcsid[] = "/b/source/CVS/src/sys/arch/amiga/dev/sd.c,v 1.1.1.1 1993/07/05 19:19:47 mw Exp"; ! 47: #endif ! 48: ! 49: #include "sys/param.h" ! 50: #include "sys/systm.h" ! 51: #include "sys/buf.h" ! 52: #include "sys/dkstat.h" ! 53: #include "sys/disklabel.h" ! 54: #include "sys/malloc.h" ! 55: #include "sys/proc.h" ! 56: #include "sys/reboot.h" ! 57: #include "sys/file.h" ! 58: ! 59: #include "device.h" ! 60: #include "scsireg.h" ! 61: #include "vm/vm_param.h" ! 62: #include "vm/lock.h" ! 63: #include "vm/vm_statistics.h" ! 64: #include "vm/pmap.h" ! 65: #include "vm/vm_prot.h" ! 66: ! 67: #include "rdb.h" ! 68: ! 69: struct sd_softc; ! 70: ! 71: extern int sdinit (register struct amiga_device *ad); ! 72: extern void sdreset (register struct sd_softc *sc, register struct amiga_device *ad); ! 73: extern int sdopen (dev_t dev, int flags, int mode, struct proc *p); ! 74: extern void sdstrategy (register struct buf *bp); ! 75: extern void sdustart (register int unit); ! 76: extern void sdstart (register int unit); ! 77: extern void sdgo (register int unit); ! 78: extern void sdintr (register int unit, int stat); ! 79: extern int sdioctl (dev_t dev, int cmd, caddr_t data, int flag, struct proc *p); ! 80: extern int sdsize (dev_t dev); ! 81: extern int sddump (dev_t dev); ! 82: static int sdident (struct sd_softc *sc, struct amiga_device *ad); ! 83: static void sdlblkstrat (register struct buf *bp, register int bsize); ! 84: static int sderror (int unit, register struct sd_softc *sc, register struct amiga_device *am, int stat); ! 85: static void sdfinish (int unit, register struct sd_softc *sc, register struct buf *bp); ! 86: ! 87: extern void disksort(); ! 88: extern int physio(); ! 89: extern void TBIS(); ! 90: ! 91: int sdinit(); ! 92: void sdstrategy(), sdstart(), sdustart(), sdgo(), sdintr(); ! 93: ! 94: struct driver sddriver = { ! 95: sdinit, "sd", (int (*)())sdstart, (int (*)())sdgo, (int (*)())sdintr, 0, ! 96: }; ! 97: ! 98: #if 0 ! 99: struct size { ! 100: u_long strtblk; ! 101: u_long endblk; ! 102: int nblocks; ! 103: }; ! 104: ! 105: struct sdinfo { ! 106: u_int cylinders; /* number of driver cylinders RDB value */ ! 107: u_int sectors; /* sectors per track RDB value */ ! 108: u_int heads; /* number of drive heads RDB value */ ! 109: u_int cylblocks; /* available number of blocks per cyl RDB value */ ! 110: struct size part[8]; ! 111: }; ! 112: ! 113: /* ! 114: * since the SCSI standard tends to hide the disk structure, we define ! 115: * partitions in terms of DEV_BSIZE blocks. The default partition table ! 116: * (for an unlabeled disk) reserves 512K for a boot area, has an 8 meg ! 117: * root and 32 meg of swap. The rest of the space on the drive goes in ! 118: * the G partition. As usual, the C partition covers the entire disk ! 119: * (including the boot area). ! 120: */ ! 121: struct sdinfo sddefaultpart = { ! 122: 1024, 17408, 16384 , /* A */ ! 123: 17408, 82944, 65536 , /* B */ ! 124: 0, 0, 0 , /* C */ ! 125: 17408, 115712, 98304 , /* D */ ! 126: 115712, 218112, 102400 , /* E */ ! 127: 218112, 0, 0 , /* F */ ! 128: 82944, 0, 0 , /* G */ ! 129: 115712, 0, 0 , /* H */ ! 130: }; ! 131: #endif ! 132: ! 133: struct sd_softc { ! 134: struct amiga_device *sc_ad; ! 135: struct devqueue sc_dq; ! 136: int sc_format_pid; /* process using "format" mode */ ! 137: short sc_flags; ! 138: short sc_type; /* drive type */ ! 139: short sc_punit; /* physical unit (scsi lun) */ ! 140: u_short sc_bshift; /* convert device blocks to DEV_BSIZE blks */ ! 141: u_int sc_blks; /* number of blocks on device */ ! 142: int sc_blksize; /* device block size in bytes */ ! 143: u_int sc_wpms; /* average xfer rate in 16 bit wds/sec. */ ! 144: char sc_idstr[32]; /* XXX */ ! 145: struct disklabel sc_label; /* drive partition table & label info */ ! 146: int sc_have_label; ! 147: int sc_write_label; ! 148: } sd_softc[NSD]; ! 149: ! 150: /* sc_flags values */ ! 151: #define SDF_ALIVE 0x1 ! 152: ! 153: #ifdef DEBUG ! 154: int sddebug = 0; ! 155: #define SDB_ERROR 0x01 ! 156: #define SDB_PARTIAL 0x02 ! 157: /*#define QUASEL*/ ! 158: #endif ! 159: ! 160: #ifdef QUASEL ! 161: #define QPRINTF(a) printf a ! 162: #else ! 163: #define QPRINTF(a) ! 164: #endif ! 165: ! 166: struct sdstats { ! 167: long sdresets; ! 168: long sdtransfers; ! 169: long sdpartials; ! 170: } sdstats[NSD]; ! 171: ! 172: struct buf sdtab[NSD]; ! 173: struct scsi_fmt_cdb sdcmd[NSD]; ! 174: struct scsi_fmt_sense sdsense[NSD]; ! 175: ! 176: static struct scsi_fmt_cdb sd_read_cmd = { 10, CMD_READ_EXT }; ! 177: static struct scsi_fmt_cdb sd_write_cmd = { 10, CMD_WRITE_EXT }; ! 178: ! 179: #define sdunit(x) (minor(x) >> 3) ! 180: #define sdpart(x) (minor(x) & 0x7) ! 181: #define sdpunit(x) ((x) & 7) ! 182: #define b_cylin b_resid ! 183: ! 184: #define SDRETRY 2 ! 185: ! 186: /* ! 187: * Table of scsi commands users are allowed to access via "format" ! 188: * mode. 0 means not legal. 1 means "immediate" (doesn't need dma). ! 189: * -1 means needs dma and/or wait for intr. ! 190: */ ! 191: static char legal_cmds[256] = { ! 192: /***** 0 1 2 3 4 5 6 7 8 9 A B C D E F */ ! 193: /*00*/ 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 194: /*10*/ 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, ! 195: /*20*/ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 196: /*30*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 197: /*40*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 198: /*50*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 199: /*60*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 200: /*70*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 201: /*80*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 202: /*90*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 203: /*a0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 204: /*b0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 205: /*c0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 206: /*d0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 207: /*e0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 208: /*f0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 209: }; ! 210: ! 211: static struct scsi_inquiry inqbuf; ! 212: static struct scsi_fmt_cdb inq = { ! 213: 6, ! 214: CMD_INQUIRY, 0, 0, 0, sizeof(inqbuf), 0 ! 215: }; ! 216: ! 217: static u_char capbuf[8]; ! 218: struct scsi_fmt_cdb cap = { ! 219: 10, ! 220: CMD_READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 ! 221: }; ! 222: ! 223: static int ! 224: sdident(sc, ad) ! 225: struct sd_softc *sc; ! 226: struct amiga_device *ad; ! 227: { ! 228: int unit; ! 229: register int ctlr, slave; ! 230: register int i; ! 231: register int tries = 10; ! 232: int ismo = 0; ! 233: ! 234: ctlr = ad->amiga_ctlr; ! 235: slave = ad->amiga_slave; ! 236: unit = sc->sc_punit; ! 237: scsi_delay(-1); ! 238: ! 239: /* ! 240: * See if unit exists and is a disk then read block size & nblocks. ! 241: */ ! 242: while ((i = scsi_test_unit_rdy(slave)) != 0) { ! 243: retry_TUR: ! 244: if (i == -1 || --tries < 0) { ! 245: if (ismo) ! 246: break; ! 247: /* doesn't exist or not a CCS device */ ! 248: goto failed; ! 249: } ! 250: if (i == STS_CHECKCOND) { ! 251: u_char sensebuf[128]; ! 252: struct scsi_xsense *sp = (struct scsi_xsense *)sensebuf; ! 253: ! 254: i = scsi_request_sense(slave, sensebuf, sizeof(sensebuf)); ! 255: if (sp->class == 7) ! 256: switch (sp->key) { ! 257: /* not ready -- might be MO with no media */ ! 258: case 2: ! 259: if (sp->len == 12 && ! 260: sensebuf[12] == 10) /* XXX */ ! 261: ismo = 1; ! 262: break; ! 263: /* drive doing an RTZ -- give it a while */ ! 264: case 6: ! 265: DELAY(1000000); ! 266: break; ! 267: default: ! 268: break; ! 269: } ! 270: } ! 271: DELAY(1000); ! 272: } ! 273: /* ! 274: * Find out about device ! 275: */ ! 276: if (i = scsi_immed_command(slave, &inq, (u_char *)&inqbuf, sizeof(inqbuf), B_READ)) ! 277: { ! 278: if (i == STS_CHECKCOND) ! 279: goto retry_TUR; ! 280: goto failed; ! 281: } ! 282: switch (inqbuf.type) { ! 283: case 0: /* disk */ ! 284: case 4: /* WORM */ ! 285: case 5: /* CD-ROM */ ! 286: case 7: /* Magneto-optical */ ! 287: break; ! 288: default: /* not a disk */ ! 289: if (sddebug) ! 290: printf ("Unit %d unknown scsi-type: %d\n", slave, inqbuf.type); ! 291: goto failed; ! 292: } ! 293: /* ! 294: * Get a usable id string ! 295: */ ! 296: if (inqbuf.version < 1) { ! 297: bcopy("UNKNOWN", &sc->sc_idstr[0], 8); ! 298: bcopy("DRIVE TYPE", &sc->sc_idstr[8], 11); ! 299: } else { ! 300: bcopy((caddr_t)&inqbuf.vendor_id, (caddr_t)sc->sc_idstr, 28); ! 301: for (i = 27; i > 23; --i) ! 302: if (sc->sc_idstr[i] != ' ') ! 303: break; ! 304: sc->sc_idstr[i+1] = 0; ! 305: for (i = 23; i > 7; --i) ! 306: if (sc->sc_idstr[i] != ' ') ! 307: break; ! 308: sc->sc_idstr[i+1] = 0; ! 309: for (i = 7; i >= 0; --i) ! 310: if (sc->sc_idstr[i] != ' ') ! 311: break; ! 312: sc->sc_idstr[i+1] = 0; ! 313: } ! 314: i = scsi_immed_command(slave, &cap, (u_char *)&capbuf, sizeof(capbuf), B_READ); ! 315: if (i) { ! 316: if (i != STS_CHECKCOND || ! 317: bcmp(&sc->sc_idstr[0], "HP", 3) || ! 318: bcmp(&sc->sc_idstr[8], "S6300.650A", 11)) ! 319: goto failed; ! 320: /* XXX unformatted or non-existant MO media; fake it */ ! 321: sc->sc_blks = 318664; ! 322: sc->sc_blksize = 1024; ! 323: } else { ! 324: sc->sc_blks = *(u_int *)&capbuf[0]; ! 325: sc->sc_blksize = *(int *)&capbuf[4]; ! 326: } ! 327: /* return value of read capacity is last valid block number */ ! 328: sc->sc_blks++; ! 329: ! 330: if (inqbuf.version < 1) ! 331: printf("sd%d: type 0x%x, qual 0x%x, ver %d", ad->amiga_unit, ! 332: inqbuf.type, inqbuf.qual, inqbuf.version); ! 333: else ! 334: printf("sd%d: %s %s rev %s", ad->amiga_unit, sc->sc_idstr, &sc->sc_idstr[8], ! 335: &sc->sc_idstr[24]); ! 336: printf(", %d %d byte blocks\n", sc->sc_blks, sc->sc_blksize); ! 337: if (sc->sc_blksize != DEV_BSIZE) { ! 338: if (sc->sc_blksize < DEV_BSIZE) { ! 339: printf("sd%d: need %d byte blocks - drive ignored\n", ! 340: unit, DEV_BSIZE); ! 341: goto failed; ! 342: } ! 343: for (i = sc->sc_blksize; i > DEV_BSIZE; i >>= 1) ! 344: ++sc->sc_bshift; ! 345: sc->sc_blks <<= sc->sc_bshift; ! 346: } ! 347: sc->sc_wpms = 32 * (60 * DEV_BSIZE / 2); /* XXX */ ! 348: scsi_delay(0); ! 349: return(inqbuf.type); ! 350: failed: ! 351: scsi_delay(0); ! 352: return(-1); ! 353: } ! 354: ! 355: int ! 356: sdinit(ad) ! 357: register struct amiga_device *ad; ! 358: { ! 359: register struct sd_softc *sc = &sd_softc[ad->amiga_unit]; ! 360: static u_int block [DEV_BSIZE / 4]; ! 361: struct RigidDiskBlock *rdb = (struct RigidDiskBlock *) block; ! 362: struct PartitionBlock *pb = (struct PartitionBlock *) block; ! 363: int bnum, npbnum, num_bsd_part = 0; ! 364: struct disklabel *dl; ! 365: ! 366: sc->sc_ad = ad; ! 367: sc->sc_punit = sdpunit(ad->amiga_flags); ! 368: sc->sc_type = sdident(sc, ad); ! 369: if (sc->sc_type < 0) ! 370: return(0); ! 371: sc->sc_dq.dq_ctlr = ad->amiga_ctlr; ! 372: sc->sc_dq.dq_unit = ad->amiga_unit; ! 373: sc->sc_dq.dq_slave = ad->amiga_slave; ! 374: sc->sc_dq.dq_driver = &sddriver; ! 375: ! 376: /* read RDB and partition blocks to find out about which partitions ! 377: are ok to be scribbled upon by BSD. This is quite Amiga specific. */ ! 378: ! 379: for (bnum = 0; bnum < RDB_LOCATION_LIMIT; bnum++) ! 380: { ! 381: if (scsi_tt_read (ad->amiga_slave, block, DEV_BSIZE, bnum, sc->sc_bshift)) ! 382: /* read error on block */ ! 383: return 0; ! 384: ! 385: if (rdb->rdb_ID == IDNAME_RIGIDDISK) ! 386: break; ! 387: } ! 388: if (bnum == RDB_LOCATION_LIMIT) ! 389: /* no RDB on this disk */ ! 390: return 0; ! 391: ! 392: /* fill in as much as we can of the disklabel */ ! 393: dl = &sc->sc_label; ! 394: bzero (dl, sizeof (*dl)); ! 395: dl->d_magic = DISKMAGIC; ! 396: dl->d_type = DTYPE_SCSI; ! 397: ! 398: strncpy (dl->d_typename, sc->sc_idstr, sizeof (dl->d_typename) - 1); ! 399: strcpy (dl->d_packname, "some pack"); ! 400: ! 401: /* now for more serious information.. */ ! 402: dl->d_secsize = rdb->rdb_BlockBytes; ! 403: dl->d_nsectors = rdb->rdb_Sectors; ! 404: dl->d_ntracks = rdb->rdb_Heads; ! 405: dl->d_ncylinders = rdb->rdb_Cylinders; ! 406: dl->d_secpercyl = rdb->rdb_CylBlocks; ! 407: dl->d_secperunit = (rdb->rdb_CylBlocks ! 408: * (rdb->rdb_HiCylinder - rdb->rdb_LoCylinder)); ! 409: ! 410: /* makes sense? */ ! 411: dl->d_acylinders = rdb->rdb_Cylinders - (rdb->rdb_HiCylinder - rdb->rdb_LoCylinder); ! 412: ! 413: dl->d_magic2 = DISKMAGIC; ! 414: ! 415: /* ok, go thru the partition blocks, and check for BSD ID's */ ! 416: ! 417: for (npbnum = rdb->rdb_PartitionList; npbnum; ) ! 418: { ! 419: u_int start_block, end_block, nblocks; ! 420: u_int reserved; ! 421: int part; ! 422: ! 423: if (scsi_tt_read (ad->amiga_slave, block, DEV_BSIZE, npbnum, sc->sc_bshift)) ! 424: break; ! 425: ! 426: if (pb->pb_ID != IDNAME_PARTITION) ! 427: break; ! 428: ! 429: /* remember those values, they're destroyed when reading the first ! 430: partition block */ ! 431: npbnum = pb->pb_Next; ! 432: start_block = pb->pb_Environment[DE_LOWCYL] * dl->d_secpercyl; ! 433: reserved = pb->pb_Environment[DE_RESERVEDBLKS]; ! 434: end_block = pb->pb_Environment[DE_UPPERCYL] * dl->d_secpercyl; ! 435: ! 436: part = -1; ! 437: switch (pb->pb_Environment[DE_DOSTYPE]) ! 438: { ! 439: case DOSTYPE_BSD_ROOT: ! 440: if (! dl->d_partitions[0].p_size) ! 441: { ! 442: extern u_long bootdev; ! 443: ! 444: part = 0; ! 445: ! 446: /* Since we don't boot BSD with a standalone-kernel, but ! 447: with a simple boot-loader from AmigaDOS, we fake a ! 448: bootdev by assigning the just computed values of the ! 449: root partition. */ ! 450: ! 451: /* 4: sd major ! 452: 0: adaptor number ! 453: 0: controller number ! 454: ad->amiga_unit: scsi-unit ! 455: part: partition (A) */ ! 456: ! 457: bootdev = MAKEBOOTDEV (4, 0, 0, ad->amiga_unit, part); ! 458: } ! 459: break; ! 460: ! 461: case DOSTYPE_BSD_SWAP: ! 462: if (! dl->d_partitions[1].p_size) ! 463: part = 1; ! 464: break; ! 465: ! 466: case DOSTYPE_BSD_D: ! 467: if (! dl->d_partitions[3].p_size) ! 468: part = 3; ! 469: break; ! 470: ! 471: case DOSTYPE_BSD_E: ! 472: if (! dl->d_partitions[4].p_size) ! 473: part = 4; ! 474: break; ! 475: ! 476: case DOSTYPE_BSD_F: ! 477: if (! dl->d_partitions[5].p_size) ! 478: part = 5; ! 479: break; ! 480: ! 481: case DOSTYPE_BSD_G: ! 482: if (! dl->d_partitions[6].p_size) ! 483: part = 6; ! 484: break; ! 485: ! 486: case DOSTYPE_BSD_H: ! 487: if (! dl->d_partitions[7].p_size) ! 488: part = 7; ! 489: break; ! 490: } ! 491: ! 492: if (part >= 0) ! 493: { ! 494: num_bsd_part++; ! 495: ! 496: dl->d_partitions[part].p_offset = start_block + reserved; ! 497: dl->d_partitions[part].p_size = end_block - start_block - reserved; ! 498: ! 499: /* for now, have this static.. XXX */ ! 500: dl->d_partitions[part].p_fsize = 1024; ! 501: dl->d_partitions[part].p_fstype = part == 1 ? FS_SWAP : FS_BSDFFS; ! 502: dl->d_partitions[part].p_frag = 8; ! 503: dl->d_partitions[part].p_cpg = 0; /* XXX */ ! 504: ! 505: if (sddebug) ! 506: printf ("%c @%d - %d = %d\n", part + 'A', ! 507: start_block, end_block, end_block - start_block - reserved); ! 508: } ! 509: } ! 510: ! 511: dl->d_npartitions = num_bsd_part; ! 512: if (sddebug) ! 513: printf ("total %d BSD-partitions.\n", num_bsd_part); ! 514: ! 515: /* C gets everything */ ! 516: dl->d_partitions[2].p_size = sc->sc_blks; ! 517: ! 518: dl->d_checksum = 0; ! 519: dl->d_checksum = dkcksum (dl); ! 520: ! 521: sc->sc_have_label = 1; ! 522: sc->sc_write_label = 0; ! 523: ! 524: sc->sc_flags = SDF_ALIVE; ! 525: return(1); ! 526: } ! 527: ! 528: void ! 529: sdreset(sc, ad) ! 530: register struct sd_softc *sc; ! 531: register struct amiga_device *ad; ! 532: { ! 533: sdstats[ad->amiga_unit].sdresets++; ! 534: } ! 535: ! 536: int ! 537: sdopen(dev, flags, mode, p) ! 538: dev_t dev; ! 539: int flags, mode; ! 540: struct proc *p; ! 541: { ! 542: register int unit = sdunit(dev); ! 543: register struct sd_softc *sc = &sd_softc[unit]; ! 544: ! 545: if (unit >= NSD) ! 546: return(ENXIO); ! 547: if ((sc->sc_flags & SDF_ALIVE) == 0 && suser(p->p_ucred, &p->p_acflag)) ! 548: return(ENXIO); ! 549: ! 550: if (sc->sc_ad->amiga_dk >= 0) ! 551: dk_wpms[sc->sc_ad->amiga_dk] = sc->sc_wpms; ! 552: return(0); ! 553: } ! 554: ! 555: /* ! 556: * This routine is called for partial block transfers and non-aligned ! 557: * transfers (the latter only being possible on devices with a block size ! 558: * larger than DEV_BSIZE). The operation is performed in three steps ! 559: * using a locally allocated buffer: ! 560: * 1. transfer any initial partial block ! 561: * 2. transfer full blocks ! 562: * 3. transfer any final partial block ! 563: */ ! 564: static void ! 565: sdlblkstrat(bp, bsize) ! 566: register struct buf *bp; ! 567: register int bsize; ! 568: { ! 569: register struct buf *cbp = (struct buf *)malloc(sizeof(struct buf), ! 570: M_DEVBUF, M_WAITOK); ! 571: caddr_t cbuf = (caddr_t)malloc(bsize, M_DEVBUF, M_WAITOK); ! 572: register int bn, resid; ! 573: register caddr_t addr; ! 574: ! 575: bzero((caddr_t)cbp, sizeof(*cbp)); ! 576: cbp->b_proc = curproc; /* XXX */ ! 577: cbp->b_dev = bp->b_dev; ! 578: bn = bp->b_blkno; ! 579: resid = bp->b_bcount; ! 580: addr = bp->b_un.b_addr; ! 581: #ifdef DEBUG ! 582: if (sddebug & SDB_PARTIAL) ! 583: printf("sdlblkstrat: bp %x flags %x bn %x resid %x addr %x\n", ! 584: bp, bp->b_flags, bn, resid, addr); ! 585: #endif ! 586: ! 587: while (resid > 0) { ! 588: register int boff = dbtob(bn) & (bsize - 1); ! 589: register int count; ! 590: ! 591: if (boff || resid < bsize) { ! 592: sdstats[sdunit(bp->b_dev)].sdpartials++; ! 593: count = MIN(resid, bsize - boff); ! 594: cbp->b_flags = B_BUSY | B_PHYS | B_READ; ! 595: cbp->b_blkno = bn - btodb(boff); ! 596: cbp->b_un.b_addr = cbuf; ! 597: cbp->b_bcount = bsize; ! 598: #ifdef DEBUG ! 599: if (sddebug & SDB_PARTIAL) ! 600: printf(" readahead: bn %x cnt %x off %x addr %x\n", ! 601: cbp->b_blkno, count, boff, addr); ! 602: #endif ! 603: sdstrategy(cbp); ! 604: biowait(cbp); ! 605: if (cbp->b_flags & B_ERROR) { ! 606: bp->b_flags |= B_ERROR; ! 607: bp->b_error = cbp->b_error; ! 608: break; ! 609: } ! 610: if (bp->b_flags & B_READ) { ! 611: bcopy(&cbuf[boff], addr, count); ! 612: goto done; ! 613: } ! 614: bcopy(addr, &cbuf[boff], count); ! 615: #ifdef DEBUG ! 616: if (sddebug & SDB_PARTIAL) ! 617: printf(" writeback: bn %x cnt %x off %x addr %x\n", ! 618: cbp->b_blkno, count, boff, addr); ! 619: #endif ! 620: } else { ! 621: count = resid & ~(bsize - 1); ! 622: cbp->b_blkno = bn; ! 623: cbp->b_un.b_addr = addr; ! 624: cbp->b_bcount = count; ! 625: #ifdef DEBUG ! 626: if (sddebug & SDB_PARTIAL) ! 627: printf(" fulltrans: bn %x cnt %x addr %x\n", ! 628: cbp->b_blkno, count, addr); ! 629: #endif ! 630: } ! 631: cbp->b_flags = B_BUSY | B_PHYS | (bp->b_flags & B_READ); ! 632: sdstrategy(cbp); ! 633: biowait(cbp); ! 634: if (cbp->b_flags & B_ERROR) { ! 635: bp->b_flags |= B_ERROR; ! 636: bp->b_error = cbp->b_error; ! 637: break; ! 638: } ! 639: done: ! 640: bn += btodb(count); ! 641: resid -= count; ! 642: addr += count; ! 643: #ifdef DEBUG ! 644: if (sddebug & SDB_PARTIAL) ! 645: printf(" done: bn %x resid %x addr %x\n", ! 646: bn, resid, addr); ! 647: #endif ! 648: } ! 649: free(cbuf, M_DEVBUF); ! 650: free(cbp, M_DEVBUF); ! 651: } ! 652: ! 653: void ! 654: sdstrategy(bp) ! 655: register struct buf *bp; ! 656: { ! 657: register int unit = sdunit(bp->b_dev); ! 658: register struct sd_softc *sc = &sd_softc[unit]; ! 659: register struct partition *pinfo = &sc->sc_label.d_partitions[sdpart(bp->b_dev)]; ! 660: register struct buf *dp = &sdtab[unit]; ! 661: register daddr_t bn; ! 662: register int sz, s; ! 663: ! 664: QPRINTF (("sdstrat: unit=%d [s=%d,l=%d], [b=%d,l=%d]\n", unit, ! 665: pinfo->p_offset, pinfo->p_size, bp->b_blkno, bp->b_bcount)); ! 666: ! 667: if (sc->sc_format_pid) { ! 668: if (sc->sc_format_pid != curproc->p_pid) { /* XXX */ ! 669: bp->b_error = EPERM; ! 670: bp->b_flags |= B_ERROR; ! 671: goto done; ! 672: } ! 673: bp->b_cylin = 0; ! 674: } else { ! 675: bn = bp->b_blkno; ! 676: sz = howmany(bp->b_bcount, DEV_BSIZE); ! 677: if (bn < 0 || bn + sz > pinfo->p_size) { ! 678: sz = pinfo->p_size - bn; ! 679: if (sz == 0) { ! 680: bp->b_resid = bp->b_bcount; ! 681: goto done; ! 682: } ! 683: if (sz < 0) { ! 684: bp->b_error = EINVAL; ! 685: bp->b_flags |= B_ERROR; ! 686: goto done; ! 687: } ! 688: bp->b_bcount = dbtob(sz); ! 689: } ! 690: /* ! 691: * Non-aligned or partial-block transfers handled specially. ! 692: */ ! 693: s = sc->sc_blksize - 1; ! 694: if ((dbtob(bn) & s) || (bp->b_bcount & s)) { ! 695: sdlblkstrat(bp, sc->sc_blksize); ! 696: goto done; ! 697: } ! 698: bp->b_cylin = (bn + pinfo->p_offset) >> sc->sc_bshift; ! 699: } ! 700: s = splbio(); ! 701: disksort(dp, bp); ! 702: if (dp->b_active == 0) { ! 703: dp->b_active = 1; ! 704: sdustart(unit); ! 705: } ! 706: splx(s); ! 707: return; ! 708: done: ! 709: biodone(bp); ! 710: } ! 711: ! 712: void ! 713: sdustart(unit) ! 714: register int unit; ! 715: { ! 716: if (scsireq(&sd_softc[unit].sc_dq)) ! 717: sdstart(unit); ! 718: } ! 719: ! 720: /* ! 721: * Return: ! 722: * 0 if not really an error ! 723: * <0 if we should do a retry ! 724: * >0 if a fatal error ! 725: */ ! 726: static int ! 727: sderror(unit, sc, am, stat) ! 728: int unit, stat; ! 729: register struct sd_softc *sc; ! 730: register struct amiga_device *am; ! 731: { ! 732: int cond = 1; ! 733: ! 734: sdsense[unit].status = stat; ! 735: if (stat & STS_CHECKCOND) { ! 736: struct scsi_xsense *sp; ! 737: ! 738: scsi_request_sense(am->amiga_slave, ! 739: sdsense[unit].sense, ! 740: sizeof(sdsense[unit].sense)); ! 741: sp = (struct scsi_xsense *)sdsense[unit].sense; ! 742: printf("sd%d: scsi sense class %d, code %d", unit, ! 743: sp->class, sp->code); ! 744: if (sp->class == 7) { ! 745: printf(", key %d", sp->key); ! 746: if (sp->valid) ! 747: printf(", blk %d", *(int *)&sp->info1); ! 748: switch (sp->key) { ! 749: /* no sense, try again */ ! 750: case 0: ! 751: cond = -1; ! 752: break; ! 753: /* recovered error, not a problem */ ! 754: case 1: ! 755: cond = 0; ! 756: break; ! 757: } ! 758: } ! 759: printf("\n"); ! 760: } ! 761: return(cond); ! 762: } ! 763: ! 764: static void ! 765: sdfinish(unit, sc, bp) ! 766: int unit; ! 767: register struct sd_softc *sc; ! 768: register struct buf *bp; ! 769: { ! 770: sdtab[unit].b_errcnt = 0; ! 771: sdtab[unit].b_actf = bp->b_actf; ! 772: bp->b_resid = 0; ! 773: biodone(bp); ! 774: scsifree(&sc->sc_dq); ! 775: if (sdtab[unit].b_actf) ! 776: sdustart(unit); ! 777: else ! 778: sdtab[unit].b_active = 0; ! 779: } ! 780: ! 781: void ! 782: sdstart(unit) ! 783: register int unit; ! 784: { ! 785: register struct sd_softc *sc = &sd_softc[unit]; ! 786: register struct amiga_device *am = sc->sc_ad; ! 787: ! 788: /* ! 789: * we have the SCSI bus -- in format mode, we may or may not need dma ! 790: * so check now. ! 791: */ ! 792: if (sc->sc_format_pid && legal_cmds[sdcmd[unit].cdb[0]] > 0) { ! 793: register struct buf *bp = sdtab[unit].b_actf; ! 794: register int sts; ! 795: ! 796: sts = scsi_immed_command(am->amiga_slave, ! 797: &sdcmd[unit], ! 798: bp->b_un.b_addr, bp->b_bcount, ! 799: bp->b_flags & B_READ); ! 800: sdsense[unit].status = sts; ! 801: if (sts & 0xfe) { ! 802: (void) sderror(unit, sc, am, sts); ! 803: bp->b_flags |= B_ERROR; ! 804: bp->b_error = EIO; ! 805: } ! 806: sdfinish(unit, sc, bp); ! 807: ! 808: } else if (scsiustart(am->amiga_ctlr)) ! 809: sdgo(unit); ! 810: } ! 811: ! 812: void ! 813: sdgo(unit) ! 814: register int unit; ! 815: { ! 816: register struct sd_softc *sc = &sd_softc[unit]; ! 817: register struct amiga_device *am = sc->sc_ad; ! 818: register struct buf *bp = sdtab[unit].b_actf; ! 819: register int pad; ! 820: register struct scsi_fmt_cdb *cmd; ! 821: ! 822: /* XXX ? */ ! 823: if (! bp) ! 824: return; ! 825: ! 826: if (sc->sc_format_pid) { ! 827: cmd = &sdcmd[unit]; ! 828: pad = 0; ! 829: } else { ! 830: cmd = bp->b_flags & B_READ? &sd_read_cmd : &sd_write_cmd; ! 831: *(int *)(&cmd->cdb[2]) = bp->b_cylin; ! 832: pad = howmany(bp->b_bcount, sc->sc_blksize); ! 833: *(u_short *)(&cmd->cdb[7]) = pad; ! 834: QPRINTF(("sdgo[%d, %d]: %s @%d >%d\n", ! 835: am->amiga_ctlr, am->amiga_slave, ! 836: bp->b_flags & B_READ ? "R" : "W", ! 837: bp->b_cylin, pad)); ! 838: pad = (bp->b_bcount & (sc->sc_blksize - 1)) != 0; ! 839: #ifdef DEBUG ! 840: if (pad) ! 841: printf("sd%d: partial block xfer -- %x bytes\n", ! 842: unit, bp->b_bcount); ! 843: #endif ! 844: sdstats[unit].sdtransfers++; ! 845: } ! 846: if (scsigo(am->amiga_ctlr, am->amiga_slave, bp, cmd, pad) == 0) { ! 847: if (am->amiga_dk >= 0) { ! 848: dk_busy |= 1 << am->amiga_dk; ! 849: ++dk_seek[am->amiga_dk]; ! 850: ++dk_xfer[am->amiga_dk]; ! 851: dk_wds[am->amiga_dk] += bp->b_bcount >> 6; ! 852: } ! 853: return; ! 854: } ! 855: #ifdef DEBUG ! 856: if (sddebug & SDB_ERROR) ! 857: printf("sd%d: sdstart: %s adr %d blk %d len %d ecnt %d\n", ! 858: unit, bp->b_flags & B_READ? "read" : "write", ! 859: bp->b_un.b_addr, bp->b_cylin, bp->b_bcount, ! 860: sdtab[unit].b_errcnt); ! 861: #endif ! 862: bp->b_flags |= B_ERROR; ! 863: bp->b_error = EIO; ! 864: sdfinish(unit, sc, bp); ! 865: } ! 866: ! 867: void ! 868: sdintr(unit, stat) ! 869: register int unit; ! 870: int stat; ! 871: { ! 872: register struct sd_softc *sc = &sd_softc[unit]; ! 873: register struct buf *bp = sdtab[unit].b_actf; ! 874: register struct amiga_device *am = sc->sc_ad; ! 875: int cond; ! 876: ! 877: if (bp == NULL) { ! 878: printf("sd%d: bp == NULL\n", unit); ! 879: return; ! 880: } ! 881: if (am->amiga_dk >= 0) ! 882: dk_busy &=~ (1 << am->amiga_dk); ! 883: if (stat) { ! 884: #ifdef DEBUG ! 885: if (sddebug & SDB_ERROR) ! 886: printf("sd%d: sdintr: bad scsi status 0x%x\n", ! 887: unit, stat); ! 888: #endif ! 889: cond = sderror(unit, sc, am, stat); ! 890: if (cond) { ! 891: if (cond < 0 && sdtab[unit].b_errcnt++ < SDRETRY) { ! 892: #ifdef DEBUG ! 893: if (sddebug & SDB_ERROR) ! 894: printf("sd%d: retry #%d\n", ! 895: unit, sdtab[unit].b_errcnt); ! 896: #endif ! 897: sdstart(unit); ! 898: return; ! 899: } ! 900: bp->b_flags |= B_ERROR; ! 901: bp->b_error = EIO; ! 902: } ! 903: } ! 904: sdfinish(unit, sc, bp); ! 905: } ! 906: ! 907: #if 1 ! 908: u_int ! 909: sdminphys (bp) ! 910: struct buf *bp; ! 911: { ! 912: register int unit = sdunit(bp->b_dev); ! 913: register struct sd_softc *sc = &sd_softc[unit]; ! 914: register struct partition *pinfo = &sc->sc_label.d_partitions[sdpart(bp->b_dev)]; ! 915: register daddr_t bn; ! 916: register int sz, s; ! 917: ! 918: /* first restrict by max amount of physio possible */ ! 919: bp->b_bcount = min(MAXPHYS, bp->b_bcount); ! 920: ! 921: /* then restrict by partition size (code replicated from sdstrategy). ! 922: Should minphys() really fiddle around with b_resid and b_flags ??? XXXX */ ! 923: ! 924: bn = bp->b_blkno; ! 925: sz = howmany(bp->b_bcount, DEV_BSIZE); ! 926: if (bn < 0 || bn + sz > pinfo->p_size) ! 927: { ! 928: sz = pinfo->p_size - bn; ! 929: if (sz == 0) ! 930: { ! 931: bp->b_resid = bp->b_bcount; ! 932: goto done; ! 933: } ! 934: if (sz < 0) ! 935: { ! 936: bp->b_error = EINVAL; ! 937: bp->b_flags |= B_ERROR; ! 938: goto done; ! 939: } ! 940: bp->b_bcount = dbtob(sz); ! 941: } ! 942: ! 943: return bp->b_bcount; ! 944: done: ! 945: return 0; ! 946: } ! 947: ! 948: ! 949: int ! 950: sdread(dev, uio, flags) ! 951: dev_t dev; ! 952: struct uio *uio; ! 953: int flags; ! 954: { ! 955: register int unit = sdunit(dev); ! 956: register int pid; ! 957: ! 958: if ((pid = sd_softc[unit].sc_format_pid) && ! 959: pid != uio->uio_procp->p_pid) ! 960: return (EPERM); ! 961: ! 962: return (physio(sdstrategy, NULL, dev, B_READ, sdminphys, uio)); ! 963: } ! 964: ! 965: int ! 966: sdwrite(dev, uio, flags) ! 967: dev_t dev; ! 968: struct uio *uio; ! 969: int flags; ! 970: { ! 971: register int unit = sdunit(dev); ! 972: register int pid; ! 973: ! 974: if ((pid = sd_softc[unit].sc_format_pid) && ! 975: pid != uio->uio_procp->p_pid) ! 976: return (EPERM); ! 977: ! 978: return (physio(sdstrategy, NULL, dev, B_WRITE, sdminphys, uio)); ! 979: } ! 980: #endif ! 981: ! 982: int ! 983: sdioctl(dev, cmd, data, flag, p) ! 984: dev_t dev; ! 985: int cmd; ! 986: caddr_t data; ! 987: int flag; ! 988: struct proc *p; ! 989: { ! 990: register int unit = sdunit(dev); ! 991: register struct sd_softc *sc = &sd_softc[unit]; ! 992: struct disklabel *dl; ! 993: int error; ! 994: ! 995: switch (cmd) { ! 996: default: ! 997: return (EINVAL); ! 998: ! 999: case DIOCGDINFO: ! 1000: *(struct disklabel *)data = sc->sc_label; ! 1001: return 0; ! 1002: ! 1003: case DIOCSDINFO: ! 1004: if ((flag & FWRITE) == 0) ! 1005: return EBADF; ! 1006: ! 1007: dl = (struct disklabel *)data; ! 1008: if (error = setdisklabel(&sc->sc_label, dl, 0, 0)); ! 1009: return error; ! 1010: sc->sc_have_label = 1; ! 1011: return 0; ! 1012: ! 1013: case DIOCWLABEL: ! 1014: if ((flag & FWRITE) == 0) ! 1015: return EBADF; ! 1016: ! 1017: sc->sc_write_label = *(int *)data; ! 1018: return 0; ! 1019: ! 1020: case DIOCWDINFO: ! 1021: if ((flag & FWRITE) == 0) ! 1022: return EBADF; ! 1023: ! 1024: dl = (struct disklabel *)data; ! 1025: ! 1026: if (error = setdisklabel (&sc->sc_label, dl, 0, 0)) ! 1027: return error; ! 1028: ! 1029: sc->sc_have_label = 1; ! 1030: ! 1031: #if 0 ! 1032: old_wlabel = as->wlabel; ! 1033: as->wlabel = 1; ! 1034: error = writedisklabel(dev, asstrategy, &as->label, ! 1035: as->dospart); ! 1036: as->wlabel = old_wlabel; ! 1037: #endif ! 1038: return EINVAL; ! 1039: ! 1040: case SDIOCSFORMAT: ! 1041: /* take this device into or out of "format" mode */ ! 1042: if (suser(p->p_ucred, &p->p_acflag)) ! 1043: return(EPERM); ! 1044: ! 1045: if (*(int *)data) { ! 1046: if (sc->sc_format_pid) ! 1047: return (EPERM); ! 1048: sc->sc_format_pid = p->p_pid; ! 1049: } else ! 1050: sc->sc_format_pid = 0; ! 1051: return (0); ! 1052: ! 1053: case SDIOCGFORMAT: ! 1054: /* find out who has the device in format mode */ ! 1055: *(int *)data = sc->sc_format_pid; ! 1056: return (0); ! 1057: ! 1058: case SDIOCSCSICOMMAND: ! 1059: /* ! 1060: * Save what user gave us as SCSI cdb to use with next ! 1061: * read or write to the char device. ! 1062: */ ! 1063: if (sc->sc_format_pid != p->p_pid) ! 1064: return (EPERM); ! 1065: if (legal_cmds[((struct scsi_fmt_cdb *)data)->cdb[0]] == 0) ! 1066: return (EINVAL); ! 1067: bcopy(data, (caddr_t)&sdcmd[unit], sizeof(sdcmd[0])); ! 1068: return (0); ! 1069: ! 1070: case SDIOCSENSE: ! 1071: /* ! 1072: * return the SCSI sense data saved after the last ! 1073: * operation that completed with "check condition" status. ! 1074: */ ! 1075: bcopy((caddr_t)&sdsense[unit], data, sizeof(sdsense[0])); ! 1076: return (0); ! 1077: ! 1078: } ! 1079: /*NOTREACHED*/ ! 1080: } ! 1081: ! 1082: int ! 1083: sdsize(dev) ! 1084: dev_t dev; ! 1085: { ! 1086: register int unit = sdunit(dev); ! 1087: register struct sd_softc *sc = &sd_softc[unit]; ! 1088: ! 1089: if (unit >= NSD || (sc->sc_flags & SDF_ALIVE) == 0) ! 1090: return(-1); ! 1091: return(sc->sc_label.d_partitions[sdpart(dev)].p_size); ! 1092: } ! 1093: ! 1094: /* ! 1095: * Non-interrupt driven, non-dma dump routine. ! 1096: */ ! 1097: int ! 1098: sddump(dev) ! 1099: dev_t dev; ! 1100: { ! 1101: int part = sdpart(dev); ! 1102: int unit = sdunit(dev); ! 1103: register struct sd_softc *sc = &sd_softc[unit]; ! 1104: register struct amiga_device *am = sc->sc_ad; ! 1105: register daddr_t baddr; ! 1106: register int maddr; ! 1107: register int pages, i; ! 1108: int stat; ! 1109: extern int lowram; ! 1110: ! 1111: /* ! 1112: * Hmm... all vax drivers dump maxfree pages which is physmem minus ! 1113: * the message buffer. Is there a reason for not dumping the ! 1114: * message buffer? Savecore expects to read 'dumpsize' pages of ! 1115: * dump, where dumpsys() sets dumpsize to physmem! ! 1116: */ ! 1117: pages = physmem; ! 1118: ! 1119: /* is drive ok? */ ! 1120: if (unit >= NSD || (sc->sc_flags & SDF_ALIVE) == 0) ! 1121: return (ENXIO); ! 1122: /* dump parameters in range? */ ! 1123: if (dumplo < 0 || dumplo >= sc->sc_label.d_partitions[part].p_size) ! 1124: return (EINVAL); ! 1125: if (dumplo + ctod(pages) > sc->sc_label.d_partitions[part].p_size) ! 1126: pages = dtoc(sc->sc_label.d_partitions[part].p_size - dumplo); ! 1127: maddr = lowram; ! 1128: baddr = dumplo + sc->sc_label.d_partitions[part].p_offset; ! 1129: /* scsi bus idle? */ ! 1130: if (!scsireq(&sc->sc_dq)) { ! 1131: scsireset(/*am->amiga_ctlr*/); ! 1132: sdreset(sc, sc->sc_ad); ! 1133: printf("[ drive %d reset ] ", unit); ! 1134: } ! 1135: for (i = 0; i < pages; i++) { ! 1136: #define NPGMB (1024*1024/NBPG) ! 1137: /* print out how many Mbs we have dumped */ ! 1138: if (i && (i % NPGMB) == 0) ! 1139: printf("%d ", i / NPGMB); ! 1140: #undef NPBMG ! 1141: pmap_enter(pmap_kernel(), vmmap, maddr, VM_PROT_READ, TRUE); ! 1142: stat = scsi_tt_write(am->amiga_slave, ! 1143: vmmap, NBPG, baddr, sc->sc_bshift); ! 1144: if (stat) { ! 1145: printf("sddump: scsi write error 0x%x\n", stat); ! 1146: return (EIO); ! 1147: } ! 1148: maddr += NBPG; ! 1149: baddr += ctod(1); ! 1150: } ! 1151: return (0); ! 1152: } ! 1153: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.