NetBSD-5.0.2/sys/arch/mvme68k/stand/libsa/bugdev.c
/* $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));
}