/*      $NetBSD: promdev.c,v 1.31 2025/01/17 10:35:47 riastradh Exp $ */

/*
* Copyright (c) 1993 Paul Kranenburg
* Copyright (c) 1995 Gordon W. Ross
* 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 Paul Kranenburg.
* 4. The name of the author may not be used to endorse or promote products
*    derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/

/*
* Note: the `#ifndef BOOTXX' in here serve to queeze the code size
* of the 1st-stage boot program.
*/
#include <sys/param.h>
#include <sys/reboot.h>
#include <sys/systm.h>
#include <machine/oldmon.h>
#include <machine/promlib.h>
#include <machine/ctlreg.h>
#include <sparc/sparc/asm.h>
#include <machine/pte.h>

#include <lib/libsa/stand.h>
#include <lib/libsa/net.h>
#include <lib/libkern/libkern.h>
#include <sparc/stand/common/promdev.h>
#include <sparc/stand/common/isfloppy.h>

#ifndef BOOTXX
#include <sys/disklabel.h>
#include <dev/sun/disklabel.h>
#include <dev/raidframe/raidframevar.h>
#endif

/* OBP V0-3 PROM vector */
#define obpvec  ((struct promvec *)romp)

int     obp_close(struct open_file *);
int     obp_strategy(void *, int, daddr_t, size_t, void *, size_t *);
int     obp_v0_strategy(void *, int, daddr_t, size_t, void *, size_t *);
ssize_t obp_v0_xmit(struct promdata *, void *, size_t);
ssize_t obp_v0_recv(struct promdata *, void *, size_t);
int     obp_v2_strategy(void *, int, daddr_t, size_t, void *, size_t *);
ssize_t obp_v2_xmit(struct promdata *, void *, size_t);
ssize_t obp_v2_recv(struct promdata *, void *, size_t);
int     oldmon_close(struct open_file *);
int     oldmon_strategy(void *, int, daddr_t, size_t, void *, size_t *);
void    oldmon_iclose(struct saioreq *);
int     oldmon_iopen(struct promdata *);
ssize_t oldmon_xmit(struct promdata *, void *, size_t);
ssize_t oldmon_recv(struct promdata *, void *, size_t);

static char     *oldmon_mapin(u_long, int, int);
#ifndef BOOTXX
static char     *mygetpropstring(int, char *);
static int      getdevtype(int, char *);
void            israidlabel(char *buf);

static daddr_t doffset = 0;
static int raidchecked = 0;

#endif

extern struct fs_ops file_system_nfs[];
extern struct fs_ops file_system_ufs[];

#define null_devopen    (void *)sparc_noop
#define null_devioctl   (void *)sparc_noop

#if 0
struct devsw devsw[];
int     ndevs = (sizeof(devsw)/sizeof(devsw[0]));
#endif

struct devsw oldmon_devsw =
       { "oldmon", oldmon_strategy, null_devopen, oldmon_close, null_devioctl };
struct devsw obp_v0_devsw =
       { "obp v0", obp_v0_strategy, null_devopen, obp_close, null_devioctl };
struct devsw obp_v2_devsw =
       { "obp v2", obp_v2_strategy, null_devopen, obp_close, null_devioctl };


char    prom_bootdevice[MAX_PROM_PATH];
static int      saveecho;

#ifndef BOOTXX
void
israidlabel(char *buf)
{
       char *partition;
       int part = 0;
       struct disklabel *dlp;

       /* Check the disklabel to see if the boot partition is type RAID.
        *
        * For machines with prom_version() == PROM_OLDMON, we
        * only handle boot from RAID for the first disk partition
        * because we only know the boot device but not the partition.
        */
       if (prom_version() != PROM_OLDMON) {
               if ((partition = strchr(prom_bootdevice, ':')) != NULL &&
                   *++partition >= 'a' &&
                   *partition <= 'a' +  MAXPARTITIONS)
                       part = *partition - 'a';
       }

#ifdef DEBUG_PROM
       printf("israidlabel: Checking disklabel for RAID partition (%c)\n",
           'a' + part);
#endif

#ifdef NOTDEF_DEBUG
       {
               int x = 0;
               char *p = (char *) buf;

               printf("Disklabel sector (%d):\n", LABELSECTOR);
               printf("00000000  ");
               while (x < DEV_BSIZE) {
                       if (*p >= 0x00 && *p < 0x10)
                               printf("0%x ", *p & 0xff);
                       else
                               printf("%x ", *p & 0xff);
                       x++;
                       if (x && !(x % 8))
                               printf(" ");
                       if (x && !(x % 16)) {
                               if(x < 0x100)
                                       printf("\n000000%x  ", x);
                               else
                                       printf("\n00000%x  ", x);
                       }
                       p++;
               }
               printf("\n");
       }
#endif
       /* Check for NetBSD disk label. */
       dlp = (struct disklabel *) (buf + LABELOFFSET);
       if (dlp->d_magic == DISKMAGIC && !dkcksum(dlp) &&
           dlp->d_partitions[part].p_fstype == FS_RAID) {
#ifdef DEBUG_PROM
               printf("israidlabel: found RAID partition, "
                   "adjusting offset to %ld\n", RF_PROTECTED_SECTORS);
#endif
               doffset = RF_PROTECTED_SECTORS;
       }
}
#endif  /* BOOTXX */

void
putchar(int c)
{

       if (c == '\n')
               prom_putchar('\r');
       prom_putchar(c);
}

void
_rtt(void)
{

       prom_halt();
}

int
devopen(struct open_file *f, const char *fname, char **file)
{
       int     error = 0, fd = 0;
       struct  promdata *pd;

       pd = (struct promdata *)alloc(sizeof *pd);
       f->f_devdata = (void *)pd;

       switch (prom_version()) {
       case PROM_OLDMON:
#ifdef DEBUG_PROM
               printf("devopen: PROM_OLDMON\n");
#endif
               error = oldmon_iopen(pd);
#ifndef BOOTXX
               pd->xmit = oldmon_xmit;
               pd->recv = oldmon_recv;
#endif
               f->f_dev = &oldmon_devsw;
               saveecho = *romVectorPtr->echo;
               *romVectorPtr->echo = 0;
               break;

       case PROM_OBP_V0:
       case PROM_OBP_V2:
       case PROM_OBP_V3:
       case PROM_OPENFIRM:
               if (*prom_bootdevice == '\0') {
                       error = ENXIO;
                       break;
               }
               fd = prom_open(prom_bootdevice);
               if (fd == 0) {
                       error = ENXIO;
                       break;
               }
               pd->fd = fd;
               switch (prom_version()) {
               case PROM_OBP_V0:
#ifdef DEBUG_PROM
                       printf("devopen: PROM_OBP_V0\n");
#endif
#ifndef BOOTXX
                       pd->xmit = obp_v0_xmit;
                       pd->recv = obp_v0_recv;
#endif
                       f->f_dev = &obp_v0_devsw;
                       break;
               case PROM_OBP_V2:
               case PROM_OBP_V3:
               case PROM_OPENFIRM:
#ifdef DEBUG_PROM
                       printf("devopen: PROM_OBP_V2+\n");
#endif
#ifndef BOOTXX
                       pd->xmit = obp_v2_xmit;
                       pd->recv = obp_v2_recv;
#endif
                       f->f_dev = &obp_v2_devsw;
               }
       }

       if (error) {
               printf("Can't open device `%s'\n", prom_bootdevice);
               return (error);
       }

#ifdef BOOTXX
       pd->devtype = DT_BLOCK;
#else /* BOOTXX */
       pd->devtype = getdevtype(fd, prom_bootdevice);
       /* Assume type BYTE is a raw device */
       if (pd->devtype != DT_BYTE)
               *file = (char *)fname;

       if (pd->devtype == DT_NET) {
               nfsys = 1;
               memcpy(file_system, file_system_nfs,
                   sizeof(struct fs_ops) * nfsys);
               if ((error = net_open(pd)) != 0) {
                       printf("Can't open NFS network connection on `%s'\n",
                               prom_bootdevice);
                       return (error);
               }
       } else
               memcpy(file_system, file_system_ufs,
                   sizeof(struct fs_ops) * nfsys);

       /* Don't check disklabel for RAID on floppy boot */
       if (bootdev_isfloppy(prom_bootdevice))
               raidchecked = 1;
#endif /* BOOTXX */
       return (0);
}


int
obp_v0_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
               void *buf, size_t *rsize)
{
       int     n, error = 0;
       struct  promdata *pd = (struct promdata *)devdata;
       int     fd = pd->fd;
#ifndef BOOTXX
       char    labelbuf[DEV_BSIZE];
#endif

#ifdef DEBUG_PROM
if (dblk < 3000)
       printf("promstrategy: size=%zd dblk=%d\n", size, (int)dblk);
#endif

#define prom_bread(fd, nblk, dblk, buf) \
               (*obpvec->pv_v0devops.v0_rbdev)(fd, nblk, dblk, buf)
#define prom_bwrite(fd, nblk, dblk, buf) \
               (*obpvec->pv_v0devops.v0_wbdev)(fd, nblk, dblk, buf)

#ifndef BOOTXX  /* We know it's a block device, so save some space */
       if (pd->devtype != DT_BLOCK) {
               printf("promstrategy: non-block device not supported\n");
               error = EINVAL;
       }

       if (!raidchecked && flag == F_READ) {
               prom_bread(fd, btodb(DEV_BSIZE), LABELSECTOR, &labelbuf[0]);
               israidlabel(&labelbuf[0]);
               raidchecked = 1;
       }
       dblk += doffset;
#endif

       n = (flag == F_READ)
               ? prom_bread(fd, btodb(size), dblk, buf)
               : prom_bwrite(fd, btodb(size), dblk, buf);

       *rsize = dbtob(n);

#ifdef DEBUG_PROM
if (dblk < 3000)
       printf("rsize = %zx\n", *rsize);
#endif
       return (error);
}

int
obp_v2_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
               void *buf, size_t *rsize)
{
       int     error = 0;
       struct  promdata *pd = (struct promdata *)devdata;
       int     fd = pd->fd;
#ifndef BOOTXX
       char    labelbuf[DEV_BSIZE];
#endif

#ifdef DEBUG_PROM
if (dblk < 3000)
       printf("promstrategy: size=%zd dblk=%d\n", size, (int)dblk);
#endif

#ifndef BOOTXX
       if (!raidchecked && flag == F_READ) {
               prom_seek(fd, dbtob(LABELSECTOR));
               prom_read(fd, &labelbuf[0], DEV_BSIZE);
               israidlabel(&labelbuf[0]);
               raidchecked = 1;
       }
       dblk += doffset;

       /* We know it's a block device, so save some space */
       if (pd->devtype == DT_BLOCK)
#endif
               prom_seek(fd, dbtob(dblk));

       *rsize = (flag == F_READ)
               ? prom_read(fd, buf, size)
               : prom_write(fd, buf, size);

#ifdef DEBUG_PROM
if (dblk < 3000)
       printf("rsize = %zx\n", *rsize);
#endif
       return (error);
}

/*
* On old-monitor machines, things work differently.
*/
int
oldmon_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
               void *buf, size_t *rsize)
{
       struct promdata *pd = devdata;
       struct saioreq  *si;
       struct om_boottable *ops;
       char    *dmabuf;
       int     si_flag;
       size_t  xcnt;
#ifndef BOOTXX
       char    labelbuf[DEV_BSIZE];
#endif

       si = pd->si;
       ops = si->si_boottab;

#ifndef BOOTXX
       dblk += doffset;
#endif
#ifdef DEBUG_PROM
if (dblk < 3000)
       printf("prom_strategy: size=%zd dblk=%d\n", size, (int)dblk);
#endif

#ifndef BOOTXX
       if (!raidchecked && flag == F_READ) {
               dmabuf = dvma_mapin(&labelbuf[0], DEV_BSIZE);
               si->si_bn = LABELSECTOR;
               si->si_cc = DEV_BSIZE;
               si_flag = SAIO_F_READ;
               xcnt = (*ops->b_strategy)(si, si_flag);
               dvma_mapout(dmabuf, DEV_BSIZE);
               israidlabel(&labelbuf[0]);
               raidchecked = 1;
       }
       dblk += doffset;
#endif

       dmabuf = dvma_mapin(buf, size);

       si->si_bn = dblk;
       si->si_ma = dmabuf;
       si->si_cc = size;

       si_flag = (flag == F_READ) ? SAIO_F_READ : SAIO_F_WRITE;
       xcnt = (*ops->b_strategy)(si, si_flag);
       dvma_mapout(dmabuf, size);

#ifdef DEBUG_PROM
if (dblk < 3000)
       printf("disk_strategy: xcnt = %zx\n", xcnt);
#endif

       if (xcnt <= 0)
               return (EIO);

       *rsize = xcnt;
       return (0);
}

int
obp_close(struct open_file *f)
{
       struct promdata *pd = f->f_devdata;
       register int fd = pd->fd;

#ifndef BOOTXX
       if (pd->devtype == DT_NET)
               net_close(pd);
#endif
       prom_close(fd);
       return 0;
}

int
oldmon_close(struct open_file *f)
{
       struct promdata *pd = f->f_devdata;

#ifndef BOOTXX
       if (pd->devtype == DT_NET)
               net_close(pd);
#endif
       oldmon_iclose(pd->si);
       pd->si = NULL;
       *romVectorPtr->echo = saveecho; /* Hmm, probably must go somewhere else */
       return 0;
}

#ifndef BOOTXX
ssize_t
obp_v0_xmit(struct promdata *pd, void *buf, size_t len)
{

       return ((*obpvec->pv_v0devops.v0_wnet)(pd->fd, len, buf));
}

ssize_t
obp_v2_xmit(struct promdata *pd, void *buf, size_t len)
{

       return (prom_write(pd->fd, buf, len));
}

ssize_t
obp_v0_recv(struct promdata *pd, void *buf, size_t len)
{

       return ((*obpvec->pv_v0devops.v0_rnet)(pd->fd, len, buf));
}

ssize_t
obp_v2_recv(struct promdata *pd, void *buf, size_t len)
{
       int     n;

       n = prom_read(pd->fd, buf, len);

       /* OBP V2 & V3 may return -2 */
       return (n == -2 ? 0 : n);
}

ssize_t
oldmon_xmit(struct promdata *pd, void *buf, size_t len)
{
       struct saioreq  *si;
       struct saif     *sif;
       char            *dmabuf;
       int             rv;

       si = pd->si;
       sif = si->si_sif;
       if (sif == NULL) {
               printf("xmit: not a network device\n");
               return (-1);
       }
       dmabuf = dvma_mapin(buf, len);
       rv = sif->sif_xmit(si->si_devdata, dmabuf, len);
       dvma_mapout(dmabuf, len);

       return (ssize_t)(rv ? -1 : len);
}

ssize_t
oldmon_recv(struct promdata *pd, void *buf, size_t len)
{
       struct saioreq  *si;
       struct saif     *sif;
       char            *dmabuf;
       int             rv;

       si = pd->si;
       sif = si->si_sif;
       dmabuf = dvma_mapin(buf, len);
       rv = sif->sif_poll(si->si_devdata, dmabuf);
       dvma_mapout(dmabuf, len);

       return (ssize_t)rv;
}

int
getchar(void)
{

       return (prom_getchar());
}

satime_t
getsecs(void)
{

       (void)prom_peekchar();
       return (prom_ticks() / 1000);
}

/*
* A number of well-known devices on sun4s.
*/
static struct dtab {
       char    *name;
       int     type;
} dtab[] = {
       { "sd", DT_BLOCK },
       { "st", DT_BLOCK },
       { "xd", DT_BLOCK },
       { "xy", DT_BLOCK },
       { "fd", DT_BLOCK },
       { "le", DT_NET },
       { "ie", DT_NET },
       { NULL, 0 }
};

int
getdevtype(int fd, char *name)
{
       struct dtab *dp;
       int node;
       char *cp;

       switch (prom_version()) {
       case PROM_OLDMON:
       case PROM_OBP_V0:
               for (dp = dtab; dp->name; dp++) {
                       if (name[0] == dp->name[0] &&
                           name[1] == dp->name[1])
                               return (dp->type);
               }
               break;

       case PROM_OBP_V2:
       case PROM_OBP_V3:
       case PROM_OPENFIRM:
               node = prom_instance_to_package(fd);
               cp = mygetpropstring(node, "device_type");
               if (strcmp(cp, "block") == 0)
                       return (DT_BLOCK);
               if (strcmp(cp, "scsi") == 0)
                       return (DT_BLOCK);
               else if (strcmp(cp, "network") == 0)
                       return (DT_NET);
               else if (strcmp(cp, "byte") == 0)
                       return (DT_BYTE);
               break;
       }
       return (0);
}

/*
* Return a string property.  There is a (small) limit on the length;
* the string is fetched into a static buffer which is overwritten on
* subsequent calls.
*/
char *
mygetpropstring(int node, char *name)
{
       int len;
static  char buf[64];

       len = prom_proplen(node, name);
       if (len > sizeof(buf))
               len = sizeof(buf)-1;
       if (len > 0)
               _prom_getprop(node, name, buf, len);
       else
               len = 0;

       buf[len] = '\0';        /* usually unnecessary */
       return (buf);
}
#endif /* BOOTXX */

/*
* Old monitor routines
*/

struct saioreq prom_si;
static int promdev_inuse;

int
oldmon_iopen(struct promdata *pd)
{
       struct om_bootparam *bp;
       struct om_boottable *ops;
       struct devinfo *dip;
       struct saioreq *si;
       int     error;

       if (promdev_inuse)
               return (EMFILE);

       bp = *romVectorPtr->bootParam;
       ops = bp->bootTable;
       dip = ops->b_devinfo;

#ifdef DEBUG_PROM
       printf("Boot device type: %s\n", ops->b_desc);
       printf("d_devbytes=%d\n", dip->d_devbytes);
       printf("d_dmabytes=%d\n", dip->d_dmabytes);
       printf("d_localbytes=%d\n", dip->d_localbytes);
       printf("d_stdcount=%d\n", dip->d_stdcount);
       printf("d_stdaddrs[%d]=%lx\n", bp->ctlrNum, dip->d_stdaddrs[bp->ctlrNum]);
       printf("d_devtype=%d\n", dip->d_devtype);
       printf("d_maxiobytes=%d\n", dip->d_maxiobytes);
#endif

       dvma_init();

       si = &prom_si;
       memset(si, 0, sizeof(*si));
       si->si_boottab = ops;
       si->si_ctlr = bp->ctlrNum;
       si->si_unit = bp->unitNum;
       si->si_boff = bp->partNum;

       if (si->si_ctlr > dip->d_stdcount)
               return (ECTLR);

       if (dip->d_devbytes) {
               si->si_devaddr = oldmon_mapin(dip->d_stdaddrs[si->si_ctlr],
                       dip->d_devbytes, dip->d_devtype);
#ifdef  DEBUG_PROM
               printf("prom_iopen: devaddr=%p pte=0x%x\n",
                       si->si_devaddr,
                       getpte4((u_long)si->si_devaddr & ~PGOFSET));
#endif
       }

       if (dip->d_dmabytes) {
               si->si_dmaaddr = dvma_alloc(dip->d_dmabytes);
#ifdef  DEBUG_PROM
               printf("prom_iopen: dmaaddr=%p\n", si->si_dmaaddr);
#endif
       }

       if (dip->d_localbytes) {
               si->si_devdata = alloc(dip->d_localbytes);
#ifdef  DEBUG_PROM
               printf("prom_iopen: devdata=%p\n", si->si_devdata);
#endif
       }

       /* OK, call the PROM device open routine. */
       error = (*ops->b_open)(si);
       if (error != 0) {
               printf("prom_iopen: \"%s\" error=%d\n", ops->b_desc, error);
               return (ENXIO);
       }
#ifdef  DEBUG_PROM
       printf("prom_iopen: succeeded, error=%d\n", error);
#endif

       pd->si = si;
       promdev_inuse++;
       return (0);
}

void
oldmon_iclose(struct saioreq *si)
{
       struct om_boottable *ops;
       struct devinfo *dip;

       if (promdev_inuse == 0)
               return;

       ops = si->si_boottab;
       dip = ops->b_devinfo;

       (*ops->b_close)(si);

       if (si->si_dmaaddr) {
               dvma_free(si->si_dmaaddr, dip->d_dmabytes);
               si->si_dmaaddr = NULL;
       }

       promdev_inuse = 0;
}

static struct mapinfo {
       int maptype;
       int pgtype;
       int base;
} oldmon_mapinfo[] = {
#define PG_COMMON       (PG_V|PG_W|PG_S|PG_NC)
       { MAP_MAINMEM,   PG_OBMEM | PG_COMMON, 0 },
       { MAP_OBIO,      PG_OBIO  | PG_COMMON, 0 },
       { MAP_MBMEM,     PG_VME16 | PG_COMMON, 0xFF000000 },
       { MAP_MBIO,      PG_VME16 | PG_COMMON, 0xFFFF0000 },
       { MAP_VME16A16D, PG_VME16 | PG_COMMON, 0xFFFF0000 },
       { MAP_VME16A32D, PG_VME32 | PG_COMMON, 0xFFFF0000 },
       { MAP_VME24A16D, PG_VME16 | PG_COMMON, 0xFF000000 },
       { MAP_VME24A32D, PG_VME32 | PG_COMMON, 0xFF000000 },
       { MAP_VME32A16D, PG_VME16 | PG_COMMON, 0 },
       { MAP_VME32A32D, PG_VME32 | PG_COMMON, 0 },
};
static int oldmon_mapinfo_cnt =
       sizeof(oldmon_mapinfo) / sizeof(oldmon_mapinfo[0]);

/* The virtual address we will use for PROM device mappings. */
static u_long prom_devmap = MONSHORTSEG;

static char *
oldmon_mapin(u_long physaddr, int length, int maptype)
{
       int i, pa, pte, va;

       if (length > (4*NBPG))
               panic("oldmon_mapin: length=%d", length);

       for (i = 0; i < oldmon_mapinfo_cnt; i++)
               if (oldmon_mapinfo[i].maptype == maptype)
                       goto found;
       panic("oldmon_mapin: invalid maptype %d", maptype);

found:
       pte = oldmon_mapinfo[i].pgtype;
       pa = oldmon_mapinfo[i].base;
       pa += physaddr;
       pte |= ((pa >> SUN4_PGSHIFT) & PG_PFNUM);

       va = prom_devmap;
       do {
               setpte4(va, pte);
               va += NBPG;
               pte += 1;
               length -= NBPG;
       } while (length > 0);
       return ((char *)(prom_devmap | (pa & PGOFSET)));
}

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.