1
0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-18 10:35:55 +00:00
freebsd/sys/dev/ofw/ofw_disk.c
2003-04-03 16:28:57 +00:00

190 lines
4.6 KiB
C

/*
* Copyright (C) 2002 Benno Rice <benno@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD$
*
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bio.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <geom/geom_disk.h>
#include <dev/ofw/openfirm.h>
#include <machine/bus.h>
#include <machine/md_var.h>
#include <machine/nexusvar.h>
#define OFWD_BLOCKSIZE 512
struct ofwd_softc
{
device_t ofwd_dev;
struct disk ofwd_disk;
phandle_t ofwd_package;
ihandle_t ofwd_instance;
};
/*
* Disk device bus interface.
*/
static void ofwd_identify(driver_t *, device_t);
static int ofwd_probe(device_t);
static int ofwd_attach(device_t);
static device_method_t ofwd_methods[] = {
DEVMETHOD(device_identify, ofwd_identify),
DEVMETHOD(device_probe, ofwd_probe),
DEVMETHOD(device_attach, ofwd_attach),
{ 0, 0 }
};
static driver_t ofwd_driver = {
"ofwd",
ofwd_methods,
sizeof(struct ofwd_softc)
};
static devclass_t ofwd_devclass;
DRIVER_MODULE(ofwd, nexus, ofwd_driver, ofwd_devclass, 0, 0);
/*
* Disk device control interface.
*/
static disk_strategy_t ofwd_strategy;
/*
* Handle an I/O request.
*/
static void
ofwd_strategy(struct bio *bp)
{
struct ofwd_softc *sc;
long r;
sc = (struct ofwd_softc *)bp->bio_disk->d_drv1;
if (sc == NULL) {
printf("ofwd: bio for invalid disk!\n");
biofinish(bp, NULL, EINVAL);
return;
}
r = OF_seek(sc->ofwd_instance,
(u_quad_t)(bp->bio_blkno * OFWD_BLOCKSIZE));
if (r == -1) {
bp->bio_resid = bp->bio_bcount;
device_printf(sc->ofwd_dev, "seek failed\n");
biofinish(bp, NULL, EIO);
return;
}
if (bp->bio_cmd == BIO_READ) {
r = OF_read(sc->ofwd_instance, (void *)bp->bio_data,
bp->bio_bcount);
} else {
r = OF_write(sc->ofwd_instance, (void *)bp->bio_data,
bp->bio_bcount);
}
if (r > bp->bio_bcount)
panic("ofwd: more bytes read/written than requested");
if (r == -1) {
device_printf(sc->ofwd_dev, "r (%ld) < bp->bio_bcount (%ld)\n",
r, bp->bio_bcount);
biofinish(bp, NULL, EIO);
return;
}
bp->bio_resid -= r;
if (r < bp->bio_bcount) {
device_printf(sc->ofwd_dev, "r (%ld) < bp->bio_bcount (%ld)\n",
r, bp->bio_bcount);
biofinish(bp, NULL, EIO); /* XXX: probably not an error */
return;
}
biodone(bp);
return;
}
/*
* Probe for an OpenFirmware disk.
*/
static int
ofwd_probe(device_t dev)
{
char *type;
type = nexus_get_device_type(dev);
if (type == NULL || strcmp(type, "disk") != 0)
return (ENXIO);
device_set_desc(dev, "OpenFirmware disk");
return (0);
}
static int
ofwd_attach(device_t dev)
{
struct ofwd_softc *sc;
char path[128];
dev_t dsk;
sc = device_get_softc(dev);
sc->ofwd_dev = dev;
bzero(path, 128);
OF_package_to_path(nexus_get_node(dev), path, 128);
device_printf(dev, "located at %s\n", path);
sc->ofwd_instance = OF_open(path);
if (sc->ofwd_instance == -1) {
device_printf(dev, "could not create instance\n");
return (ENXIO);
}
sc->ofwd_disk.d_strategy = ofwd_strategy;
sc->ofwd_disk.d_name = "ofwd";
sc->ofwd_disk.d_sectorsize = OFWD_BLOCKSIZE;
sc->ofwd_disk.d_mediasize = (off_t)33554432 * OFWD_BLOCKSIZE;
sc->ofwd_disk.d_fwsectors = 0;
sc->ofwd_disk.d_fwheads = 0;
sc->ofwd_disk.d_drv1 = sc;
sc->ofwd_disk.d_maxsize = PAGE_SIZE;
disk_create(device_get_unit(dev), &sc->ofwd_disk, 0, NULL, NULL);
return (0);
}
static void
ofwd_identify(driver_t *driver, device_t parent)
{
}