/*      $NetBSD: bugdev.c,v 1.12 2008/04/28 20:23:29 martin Exp $       */

/*-
* Copyright (c) 1998 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Paul Kranenburg.
*
* 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 THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``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 THE FOUNDATION OR CONTRIBUTORS
* 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/param.h>
#include <sys/disklabel.h>
#include <machine/prom.h>

#include <lib/libsa/stand.h>
#include "libsa.h"

void cputobsdlabel(struct disklabel *lp, struct cpu_disklabel *clp);

int errno;

struct bugsc_softc {
       int     fd;     /* Prom file descriptor */
       int     poff;   /* Partition offset */
       int     psize;  /* Partition size */
       short   ctrl;
       short   dev;
} bugsc_softc[1];

int
devopen(struct open_file *f, const char *fname, char **file)
{
       struct bugsc_softc *pp = &bugsc_softc[0];
       int     error, pn = 0;
       char    *dev, *cp;
       size_t  nrd;
       static  int iobuf[DEV_BSIZE / sizeof(int)];
       struct disklabel sdlabel;

       dev = bugargs.arg_start;

       /*
        * Extract partition # from boot device string.
        * The Bug command line format of this is:
        *
        *   147-Bug> bo [drive],,[<d>:][kernel_name] [options]
        *
        * Where:
        *       [drive]         The bug LUN number, eg. 0
        *       [<d>:]          <d> is partition # ('a' to 'h')
        *       [kernel_name]   Eg. netbsd or /netbsd
        *       [options]       Eg. -s
        *
        * At this time, all we need do is scan for a ':', and assume the
        * preceding letter is a partition id.
        */
       for (cp = dev + 1; *cp && cp <= bugargs.arg_end; cp++) {
               if ( *cp == ':' ) {
                       pn = *(cp - 1) - 'a';
                       break;
               }
       }

       if ( pn < 0 || pn >= MAXPARTITIONS ) {
               printf("Invalid partition number; defaulting to 'a'\n");
               pn = 0;
       }

       pp->fd = bugscopen(f);

       if (pp->fd < 0) {
               printf("Can't open device `%s'\n", dev);
               return ENXIO;
       }
       error = bugscstrategy(pp, F_READ, LABELSECTOR, DEV_BSIZE, iobuf, &nrd);
       if (error)
               return error;
       if (nrd != DEV_BSIZE)
               return EINVAL;

       /*LINTED*/
       cputobsdlabel(&sdlabel, (struct cpu_disklabel *)&(iobuf[0]));
       pp->poff = sdlabel.d_partitions[pn].p_offset;
       pp->psize = sdlabel.d_partitions[pn].p_size;

       f->f_dev = devsw;
       f->f_devdata = (void *)pp;
       /*LINTED*/
       *file = (char *)fname;
       return 0;
}

/* silly block scale factor */
#define BUG_BLOCK_SIZE 256
#define BUG_SCALE (512/BUG_BLOCK_SIZE)
/*ARGSUSED*/
int
bugscstrategy(void *devdata, int func, daddr_t dblk, size_t size, void *buf,
             size_t *rsize)
{
       struct mvmeprom_dskio dio;
       struct bugsc_softc *pp = (struct bugsc_softc *)devdata;
       daddr_t blk = dblk + pp->poff;

       twiddle();

       dio.ctrl_lun = pp->ctrl;
       dio.dev_lun = pp->dev;
       dio.status = 0;
       dio.pbuffer = buf;
       dio.blk_num = blk * BUG_SCALE;
       dio.blk_cnt = size / BUG_BLOCK_SIZE; /* assumed size in bytes */
       dio.flag = 0;
       dio.addr_mod = 0;
#ifdef DEBUG
       printf("bugscstrategy: size=%d blk=%d buf=%x\n", size, blk, buf);
       printf("ctrl %d dev %d\n", dio.ctrl_lun, dio.dev_lun);
#endif
       mvmeprom_diskrd(&dio);

       *rsize = dio.blk_cnt * BUG_BLOCK_SIZE;
#ifdef DEBUG
       printf("rsize %d status %x\n", *rsize, dio.status);
#endif

       if (dio.status)
               return EIO;
       return 0;
}

int
bugscopen(struct open_file *f, ...)
{

#ifdef DEBUG
       printf("bugscopen:\n");
#endif

       f->f_devdata = (void *)bugsc_softc;
       bugsc_softc[0].ctrl = (short)bugargs.ctrl_lun;
       bugsc_softc[0].dev =  (short)bugargs.dev_lun;
#ifdef DEBUG
       printf("using mvmebug ctrl %d dev %d\n",
           bugsc_softc[0].ctrl, bugsc_softc[0].dev);
#endif
       return 0;
}

/*ARGSUSED*/
int
bugscclose(struct open_file *f)
{

       return EIO;
}

/*ARGSUSED*/
int
bugscioctl(struct open_file *f, u_long cmd, void *data)
{

       return EIO;
}

void
cputobsdlabel(struct disklabel *lp, struct cpu_disklabel *clp)
{
       int i;

       lp->d_magic   = (uint32_t)clp->magic1;
       lp->d_type    = (uint16_t)clp->type;
       lp->d_subtype = (uint16_t)clp->subtype;

       memcpy(lp->d_typename, clp->vid_vd, 16);
       memcpy(lp->d_packname, clp->packname, 16);

       lp->d_secsize        = (uint32_t)clp->cfg_psm;
       lp->d_nsectors       = (uint32_t)clp->cfg_spt;
       lp->d_ncylinders     = (uint32_t)clp->cfg_trk; /* trk is num of cyl! */
       lp->d_ntracks        = (uint32_t)clp->cfg_hds;
       lp->d_secpercyl      = (uint32_t)clp->secpercyl;
       lp->d_secperunit     = (uint32_t)clp->secperunit;
       lp->d_sparespertrack = (uint16_t)clp->sparespertrack;
       lp->d_sparespercyl   = (uint16_t)clp->sparespercyl;
       lp->d_acylinders     = (uint32_t)clp->acylinders;
       lp->d_rpm            = (uint16_t)clp->rpm;
       lp->d_interleave     = (uint16_t)clp->cfg_ilv;
       lp->d_trackskew      = (uint16_t)clp->cfg_sof;
       lp->d_cylskew        = (uint16_t)clp->cylskew;
       lp->d_headswitch     = (uint32_t)clp->headswitch;

       /* this silly table is for winchester drives */
       switch (clp->cfg_ssr) {
       case 0:
               lp->d_trkseek = 0;
               break;
       case 1:
               lp->d_trkseek = 6;
               break;
       case 2:
               lp->d_trkseek = 10;
               break;
       case 3:
               lp->d_trkseek = 15;
               break;
       case 4:
               lp->d_trkseek = 20;
               break;
       default:
               lp->d_trkseek = 0;
               break;
       }
       lp->d_flags = (uint32_t)clp->flags;

       for (i = 0; i < NDDATA; i++)
               lp->d_drivedata[i] = (uint32_t)clp->drivedata[i];

       for (i = 0; i < NSPARE; i++)
               lp->d_spare[i] = (uint32_t)clp->spare[i];

       lp->d_magic2      = (uint32_t)clp->magic2;
       lp->d_checksum    = (uint16_t)clp->checksum;
       lp->d_npartitions = (uint16_t)clp->partitions;
       lp->d_bbsize      = (uint32_t)clp->bbsize;
       lp->d_sbsize      = (uint32_t)clp->sbsize;

       memcpy(&(lp->d_partitions[0]), clp->vid_4,
           sizeof(struct partition) * 4);

       /* CONSTCOND */
       memcpy(&(lp->d_partitions[4]), clp->cfg_4, sizeof(struct partition)
           * ((MAXPARTITIONS < 16) ? (MAXPARTITIONS - 4) : 12));
}

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.