/*      $NetBSD: ofdisk.c,v 1.54 2020/01/26 21:43:52 thorpej Exp $      */

/*
* Copyright (C) 1995, 1996 Wolfgang Solfrank.
* Copyright (C) 1995, 1996 TooLs GmbH.
* 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.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by TooLs GmbH.
* 4. The name of TooLs GmbH may not be used to endorse or promote products
*    derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ofdisk.c,v 1.54 2020/01/26 21:43:52 thorpej Exp $");

#include <sys/param.h>
#include <sys/buf.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <sys/disklabel.h>
#include <sys/disk.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/systm.h>
#include <sys/proc.h>

#include <dev/ofw/openfirm.h>

struct ofdisk_softc {
       device_t sc_dev;
       int sc_phandle;
       int sc_unit;
       int sc_flags;
       struct disk sc_dk;
       int sc_ihandle;
       u_long max_transfer;
};

/* sc_flags */
#define OFDF_ISFLOPPY   0x01            /* we are a floppy drive */

#define OFDISK_FLOPPY_P(of)             ((of)->sc_flags & OFDF_ISFLOPPY)

static int ofdisk_match (device_t, cfdata_t, void *);
static void ofdisk_attach (device_t, device_t, void *);

CFATTACH_DECL_NEW(ofdisk, sizeof(struct ofdisk_softc),
   ofdisk_match, ofdisk_attach, NULL, NULL);

extern struct cfdriver ofdisk_cd;

dev_type_open(ofdisk_open);
dev_type_close(ofdisk_close);
dev_type_read(ofdisk_read);
dev_type_write(ofdisk_write);
dev_type_ioctl(ofdisk_ioctl);
dev_type_strategy(ofdisk_strategy);
dev_type_dump(ofdisk_dump);
dev_type_size(ofdisk_size);

const struct bdevsw ofdisk_bdevsw = {
       .d_open = ofdisk_open,
       .d_close = ofdisk_close,
       .d_strategy = ofdisk_strategy,
       .d_ioctl = ofdisk_ioctl,
       .d_dump = ofdisk_dump,
       .d_psize = ofdisk_size,
       .d_discard = nodiscard,
       .d_flag = D_DISK
};

const struct cdevsw ofdisk_cdevsw = {
       .d_open = ofdisk_open,
       .d_close = ofdisk_close,
       .d_read = ofdisk_read,
       .d_write = ofdisk_write,
       .d_ioctl = ofdisk_ioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = nommap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = D_DISK
};

static void ofminphys(struct buf *);

struct dkdriver ofdisk_dkdriver = {
       .d_strategy = ofdisk_strategy,
       .d_minphys = ofminphys
};

void ofdisk_getdefaultlabel (struct ofdisk_softc *, struct disklabel *);
void ofdisk_getdisklabel (dev_t);

static int
ofdisk_match(device_t parent, cfdata_t match, void *aux)
{
       struct ofbus_attach_args *oba = aux;
       char type[8];
       int l;

       if (strcmp(oba->oba_busname, "ofw"))
               return (0);
       if ((l = OF_getprop(oba->oba_phandle, "device_type", type,
           sizeof type - 1)) < 0)
               return 0;
       if (l >= sizeof type)
               return 0;
       type[l] = 0;
       return strcmp(type, "block") == 0 || strcmp(type, "scsi") == 0;
}

static void
ofdisk_attach(device_t parent, device_t self, void *aux)
{
       struct ofdisk_softc *of = device_private(self);
       struct ofbus_attach_args *oba = aux;
       char child[64];
       int l;

       of->sc_dev = self;
       if ((l = OF_getprop(oba->oba_phandle, "name", child,
           sizeof child - 1)) < 0)
               panic("device without name?");
       if (l >= sizeof child)
               l = sizeof child - 1;
       child[l] = 0;

       of->sc_flags = 0;
       of->sc_phandle = oba->oba_phandle;
       of->sc_unit = oba->oba_unit;
       of->sc_ihandle = 0;
       disk_init(&of->sc_dk, device_xname(of->sc_dev), &ofdisk_dkdriver);
       disk_attach(&of->sc_dk);
       printf("\n");

       if (strcmp(child, "floppy") == 0)
               of->sc_flags |= OFDF_ISFLOPPY;
       else {
               /* Discover wedges on this disk. */
               dkwedge_discover(&of->sc_dk);
       }
}

int
ofdisk_open(dev_t dev, int flags, int fmt, struct lwp *lwp)
{
       struct ofdisk_softc *of;
       char path[256];
       int error, l, part;

       of = device_lookup_private(&ofdisk_cd, DISKUNIT(dev));
       if (of == NULL)
               return ENXIO;

       part = DISKPART(dev);

       mutex_enter(&of->sc_dk.dk_openlock);

       /*
        * If there are wedges, and this is not RAW_PART, then we
        * need to fail.
        */
       if (of->sc_dk.dk_nwedges != 0 && part != RAW_PART) {
               error = EBUSY;
               goto bad1;
       }

       if (!of->sc_ihandle) {
               if ((l = OF_package_to_path(of->sc_phandle, path,
                   sizeof path - 3)) < 0 ||
                   l >= sizeof path - 3) {
                       error = ENXIO;
                       goto bad1;
               }
               path[l] = 0;

               /*
                * XXX This is for the benefit of SCSI/IDE disks that don't
                * XXX have all their childs in the device tree.
                * XXX YES, I DO THINK THIS IS A BUG IN OPENFIRMWARE!!!
                * XXX And yes, this is a very gross hack!
                * XXX See also ofscsi.c
                */
               if (!strcmp(path + l - 4, "disk")) {
                       path[l++] = '@';
                       path[l++] = '0' + of->sc_unit;
                       path[l] = 0;
               }

               strlcat(path, ":0", sizeof(path));

               if ((of->sc_ihandle = OF_open(path)) == -1) {
                       error = ENXIO;
                       goto bad1;
               }

               /*
                * Try to get characteristics of the disk.
                */
               of->max_transfer = OF_call_method_1("max-transfer",
                   of->sc_ihandle, 0);
               if (of->max_transfer > MAXPHYS)
                       of->max_transfer = MAXPHYS;

               ofdisk_getdisklabel(dev);
       }

       switch (fmt) {
       case S_IFCHR:
               of->sc_dk.dk_copenmask |= 1 << part;
               break;
       case S_IFBLK:
               of->sc_dk.dk_bopenmask |= 1 << part;
               break;
       }
       of->sc_dk.dk_openmask =
           of->sc_dk.dk_copenmask | of->sc_dk.dk_bopenmask;


       error = 0;
bad1:
       mutex_exit(&of->sc_dk.dk_openlock);
       return (error);
}

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;
}

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 void
ofminphys(struct buf *bp)
{
       struct ofdisk_softc *of =
               device_lookup_private(&ofdisk_cd, DISKUNIT(bp->b_dev));

       if (bp->b_bcount > of->max_transfer)
               bp->b_bcount = of->max_transfer;
}

int
ofdisk_read(dev_t dev, struct uio *uio, int flags)
{
       return physio(ofdisk_strategy, NULL, dev, B_READ, ofminphys, uio);
}

int
ofdisk_write(dev_t dev, struct uio *uio, int flags)
{
       return physio(ofdisk_strategy, NULL, dev, B_WRITE, ofminphys, uio);
}

int
ofdisk_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
       struct ofdisk_softc *of =
               device_lookup_private(&ofdisk_cd, DISKUNIT(dev));
       int error;
#ifdef __HAVE_OLD_DISKLABEL
       struct disklabel newlabel;
#endif
       /* XXX: Why not allow wedges on floppy? */
       switch (cmd) {
       case DIOCDWEDGE:
       case DIOCAWEDGE:
       case DIOCLWEDGES:
       case DIOCRMWEDGES:
       case DIOCMWEDGES:
               if (OFDISK_FLOPPY_P(of))
                       return ENOTTY;
       }

       error = disk_ioctl(&of->sc_dk, dev, cmd, data, flag, l);
       if (error != EPASSTHROUGH)
               return error;

       switch (cmd) {
       case DIOCWDINFO:
       case DIOCSDINFO:
#ifdef __HAVE_OLD_DISKLABEL
       case ODIOCWDINFO:
       case ODIOCSDINFO:
#endif
       {
               struct disklabel *lp;

#ifdef __HAVE_OLD_DISKLABEL
               if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) {
                       memset(&newlabel, 0, sizeof newlabel);
                       memcpy(&newlabel, data, sizeof (struct olddisklabel));
                       lp = &newlabel;
               } else
#endif
               lp = (struct disklabel *)data;

               if ((flag & FWRITE) == 0)
                       return EBADF;

               mutex_enter(&of->sc_dk.dk_openlock);

               error = setdisklabel(of->sc_dk.dk_label,
                   lp, /*of->sc_dk.dk_openmask */0,
                   of->sc_dk.dk_cpulabel);
               if (error == 0 && (cmd == DIOCWDINFO
#ifdef __HAVE_OLD_DISKLABEL
                   || cmd == ODIOCWDINFO
#endif
                   ))
                       error = writedisklabel(MAKEDISKDEV(major(dev),
                           DISKUNIT(dev), RAW_PART), ofdisk_strategy,
                           of->sc_dk.dk_label, of->sc_dk.dk_cpulabel);

               mutex_exit(&of->sc_dk.dk_openlock);

               return error;
       }

       case DIOCGDEFLABEL:
               ofdisk_getdefaultlabel(of, (struct disklabel *)data);
               return 0;
#ifdef __HAVE_OLD_DISKLABEL
       case ODIOCGDEFLABEL:
               ofdisk_getdefaultlabel(of, &newlabel);
               if (newlabel.d_npartitions > OLDMAXPARTITIONS)
                       return ENOTTY;
               memcpy(data, &newlabel, sizeof (struct olddisklabel));
               return 0;
#endif

       default:
               return ENOTTY;
       }
}

int
ofdisk_dump(dev_t dev, daddr_t blkno, void *va, size_t size)
{
       return EINVAL;
}

int
ofdisk_size(dev_t dev)
{
       struct ofdisk_softc *of;
       struct disklabel *lp;
       int size, part, omask;

       of = device_lookup_private(&ofdisk_cd, DISKUNIT(dev));
       if (of == NULL)
               return ENXIO;

       part = DISKPART(dev);
       omask = of->sc_dk.dk_openmask & (1 << part);
       lp = of->sc_dk.dk_label;

       if (omask == 0 && ofdisk_open(dev, 0, S_IFBLK, curlwp) != 0)
               return -1;

       if (lp->d_partitions[part].p_fstype != FS_SWAP)
               size = -1;
       else
               size = lp->d_partitions[part].p_size *
                   (lp->d_secsize / DEV_BSIZE);

       if (omask == 0 && ofdisk_close(dev, 0, S_IFBLK, curlwp) != 0)
               return -1;

       return size;
}

void
ofdisk_getdefaultlabel(struct ofdisk_softc *of, struct disklabel *lp)
{

       memset(lp, 0, sizeof *lp);

       /*
        * XXX Firmware bug?  Asking for block size gives a
        * XXX ridiculous number!  So we use what the boot program
        * XXX uses.
        */
       lp->d_secsize = DEV_BSIZE;

       lp->d_secperunit = OF_call_method_1("#blocks",
           of->sc_ihandle, 0);
       if (lp->d_secperunit == (u_int32_t)-1)
               lp->d_secperunit = 0x7fffffff;

       lp->d_secpercyl = 1;
       lp->d_nsectors = 1;
       lp->d_ntracks = 1;
       lp->d_ncylinders = lp->d_secperunit;

       lp->d_partitions[RAW_PART].p_offset = 0;
       lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
       lp->d_npartitions = RAW_PART + 1;

       lp->d_magic = DISKMAGIC;
       lp->d_magic2 = DISKMAGIC;
       lp->d_checksum = dkcksum(lp);
}

void
ofdisk_getdisklabel(dev_t dev)
{
       int unit = DISKUNIT(dev);
       struct ofdisk_softc *of =
               device_lookup_private(&ofdisk_cd, unit);
       struct disklabel *lp = of->sc_dk.dk_label;
       const char *errmes;
       int l;

       ofdisk_getdefaultlabel(of, lp);

       /*
        * Don't read the disklabel on a floppy; simply
        * assign all partitions the same size/offset as
        * RAW_PART.  (This is essentially what the ISA
        * floppy driver does, but we don't deal with
        * density stuff.)
        */
       if (OFDISK_FLOPPY_P(of)) {
               lp->d_npartitions = MAXPARTITIONS;
               for (l = 0; l < lp->d_npartitions; l++) {
                       if (l == RAW_PART)
                               continue;
                       /* struct copy */
                       lp->d_partitions[l] =
                           lp->d_partitions[RAW_PART];
               }
               lp->d_checksum = dkcksum(lp);
       } else {
               errmes = readdisklabel(MAKEDISKDEV(major(dev),
                   unit, RAW_PART), ofdisk_strategy, lp,
                   of->sc_dk.dk_cpulabel);
               if (errmes != NULL)
                       printf("%s: %s\n", device_xname(of->sc_dev), errmes);
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.