static int
strategy(void *devdata, int rw, daddr32_t blk, size_t size, void *buf,
size_t *rsize)
{
struct of_dev *dev = devdata;
u_quad_t pos;
int n;
if (rw != F_READ)
return EPERM;
if (dev->type != OFDEV_DISK)
panic("strategy");
pos = (u_quad_t)(blk + dev->partoff) * dev->bsize;
for (;;) {
if (OF_seek(dev->handle, pos) < 0)
break;
n = OF_read(dev->handle, buf, size);
if (n == -2)
continue;
if (n < 0)
break;
*rsize = n;
return 0;
}
return EIO;
}
static int
strategy(void *devdata, int rw, daddr32_t blk, size_t size, void *buf,
size_t *rsize)
{
struct of_dev *dev = devdata;
u_quad_t pos;
int n;
if (rw != F_READ)
return EPERM;
if (dev->type != OFDEV_DISK)
panic("strategy");
DNPRINTF(BOOT_D_OFDEV, "strategy: block %lx, partition offset %lx, "
"blksz %lx\n", (long)blk, (long)dev->partoff, (long)dev->bsize);
DNPRINTF(BOOT_D_OFDEV, "strategy: seek position should be: %lx\n",
(long)((blk + dev->partoff) * dev->bsize));
pos = (u_quad_t)(blk + dev->partoff) * dev->bsize;
for (;;) {
DNPRINTF(BOOT_D_OFDEV, "strategy: seeking to %lx\n", (long)pos);
if (OF_seek(dev->handle, pos) < 0)
break;
DNPRINTF(BOOT_D_OFDEV, "strategy: reading %lx at %p\n",
(long)size, buf);
n = OF_read(dev->handle, buf, size);
if (n == -2)
continue;
if (n < 0)
break;
*rsize = n;
return 0;
}
return EIO;
}
static int
ofwd_strategy(void *devdata, int flag __unused, daddr_t dblk, size_t size,
char *buf, size_t *rsize)
{
struct ofw_devdesc *dp = (struct ofw_devdesc *)devdata;
daddr_t pos;
int n;
if (dp != kdp) {
if (kdp != NULL) {
#if !defined(__powerpc__)
OF_close(kdp->d_handle);
#endif
kdp = NULL;
}
if ((dp->d_handle = OF_open(dp->d_path)) == -1)
return (ENOENT);
kdp = dp;
}
pos = dblk * 512;
do {
if (OF_seek(dp->d_handle, pos) < 0)
return (EIO);
n = OF_read(dp->d_handle, buf, size);
if (n < 0 && n != -2)
return (EIO);
} while (n == -2);
*rsize = size;
return (0);
}
int
ofdisk_close(dev_t dev, int flags, int fmt, struct lwp *l)
{
struct ofdisk_softc *of =
device_lookup_private(&ofdisk_cd, DISKUNIT(dev));
mutex_enter(&of->sc_dk.dk_openlock);
switch (fmt) {
case S_IFCHR:
of->sc_dk.dk_copenmask &= ~(1 << DISKPART(dev));
break;
case S_IFBLK:
of->sc_dk.dk_bopenmask &= ~(1 << DISKPART(dev));
break;
}
of->sc_dk.dk_openmask = of->sc_dk.dk_copenmask | of->sc_dk.dk_bopenmask;
#ifdef FIRMWORKSBUGS
/*
* This is a hack to get the firmware to flush its buffers.
*/
OF_seek(of->sc_ihandle, 0);
#endif
if (!of->sc_dk.dk_openmask) {
OF_close(of->sc_ihandle);
of->sc_ihandle = 0;
}
mutex_exit(&of->sc_dk.dk_openlock);
return 0;
}
off_t
hfs_seek(struct open_file *f, off_t offset, int where)
{
switch (where) {
case SEEK_SET:
return OF_seek(OF_fd, offset);
case SEEK_CUR:
case SEEK_END:
default:
return -1;
}
}
void
ofdisk_strategy(struct buf *bp)
{
struct ofdisk_softc *of =
device_lookup_private(&ofdisk_cd, DISKUNIT(bp->b_dev));
struct partition *p;
u_quad_t off;
int read;
int (*OF_io)(int, void *, int);
daddr_t blkno = bp->b_blkno;
bp->b_resid = 0;
if (bp->b_bcount == 0)
goto done;
OF_io = bp->b_flags & B_READ ? OF_read :
(int(*)(int, void*, int))OF_write;
if (DISKPART(bp->b_dev) != RAW_PART) {
if (bounds_check_with_label(&of->sc_dk, bp, 0) <= 0) {
bp->b_resid = bp->b_bcount;
goto done;
}
p = &of->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
blkno = bp->b_blkno + p->p_offset;
}
disk_busy(&of->sc_dk);
off = (u_quad_t)blkno * DEV_BSIZE;
read = -1;
do {
if (OF_seek(of->sc_ihandle, off) < 0)
break;
read = OF_io(of->sc_ihandle, bp->b_data, bp->b_bcount);
} while (read == -2);
if (read < 0) {
bp->b_error = EIO;
bp->b_resid = bp->b_bcount;
} else
bp->b_resid = bp->b_bcount - read;
disk_unbusy(&of->sc_dk, bp->b_bcount - bp->b_resid,
(bp->b_flags & B_READ));
done:
biodone(bp);
}
static int
ofwd_strategy(void *devdata, int flag, daddr_t dblk, size_t size, char *buf,
size_t *rsize)
{
struct ofw_devdesc *dp = (struct ofw_devdesc *)devdata;
unsigned long pos;
int n;
int i, j;
pos = dblk * 512;
do {
if (OF_seek(dp->d_handle, pos) < 0)
return EIO;
n = OF_read(dp->d_handle, buf, size);
if (n < 0 && n != -2)
return EIO;
} while (n == -2);
*rsize = size;
return 0;
}
int
strategy(void *devdata, int rw, daddr32_t blk, size_t size, void *buf,
size_t *rsize)
{
struct of_dev *dev = devdata;
u_quad_t pos;
int n;
if (rw != F_READ)
return EPERM;
#ifdef SOFTRAID
/* Intercept strategy for softraid volumes. */
if (dev->type == OFDEV_SOFTRAID)
return sr_strategy(bootdev_dip->sr_vol, rw,
blk, size, buf, rsize);
#endif
if (dev->type != OFDEV_DISK)
panic("strategy");
DNPRINTF(BOOT_D_OFDEV, "strategy: block %lx, partition offset %lx, "
"blksz %lx\n", (long)blk, (long)dev->partoff, (long)dev->bsize);
DNPRINTF(BOOT_D_OFDEV, "strategy: seek position should be: %lx\n",
(long)((blk + dev->partoff) * dev->bsize));
pos = (u_quad_t)(blk + dev->partoff) * dev->bsize;
for (;;) {
DNPRINTF(BOOT_D_OFDEV, "strategy: seeking to %lx\n", (long)pos);
if (OF_seek(dev->handle, pos) < 0)
break;
DNPRINTF(BOOT_D_OFDEV, "strategy: reading %lx at %p\n",
(long)size, buf);
n = OF_read(dev->handle, buf, size);
if (n == -2)
continue;
if (n < 0)
break;
*rsize = n;
return 0;
}
return EIO;
}