NetBSD/sys/arch/vax/boot/xxboot/bootxx.c

418 lines
10 KiB
C

/* $NetBSD: bootxx.c,v 1.14 2000/11/09 01:54:20 matt Exp $ */
/*-
* Copyright (c) 1982, 1986 The Regents of the University of California.
* 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 the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)boot.c 7.15 (Berkeley) 5/4/91
*/
#include "sys/param.h"
#include "sys/reboot.h"
#include "sys/disklabel.h"
#include "sys/exec.h"
#include "sys/exec_elf.h"
#include "lib/libsa/stand.h"
#include "lib/libsa/ufs.h"
#include "lib/libsa/cd9660.h"
#include "lib/libkern/libkern.h"
#include "machine/pte.h"
#include "machine/sid.h"
#include "machine/mtpr.h"
#include "machine/reg.h"
#include "machine/rpb.h"
#include "../vax/gencons.h"
#include "../mba/mbareg.h"
#include "../mba/hpreg.h"
#define NRSP 1 /* Kludge */
#define NCMD 1 /* Kludge */
#include "dev/mscp/mscp.h"
#include "dev/mscp/mscpreg.h"
#include "../boot/data.h"
#define RF_PROTECTED_SECTORS 64 /* XXX refer to <.../rf_optnames.h> */
void Xmain(void);
void hoppabort(int);
void romread_uvax(int lbn, int size, void *buf, struct rpb *rpb);
void hpread(int block);
int read750(int block, int *regs);
int unit_init(int, struct rpb *, int);
struct open_file file;
unsigned *bootregs;
struct rpb *rpb;
struct bqo *bqo;
int vax_cputype;
int vax_load_failure;
struct udadevice {u_short udaip;u_short udasa;};
volatile struct udadevice *csr;
static int moved;
extern int from;
#define FROM750 1
#define FROMMV 2
#define FROMVMB 4
/*
* The boot block are used by 11/750, 8200, MicroVAX II/III, VS2000,
* VS3100/??, VS4000 and VAX6000/???, and only when booting from disk.
*/
void
Xmain()
{
union {
struct exec aout;
Elf32_Ehdr elf;
} hdr;
int io;
u_long entry;
vax_cputype = (mfpr(PR_SID) >> 24) & 0xFF;
moved = 0;
/*
*/
rpb = (void *)0xf0000; /* Safe address right now */
bqo = (void *)0xf1000;
if (from == FROMMV) {
/*
* now relocate rpb/bqo (which are used by ROM-routines)
*/
bcopy ((void *)bootregs[11], rpb, sizeof(struct rpb));
bcopy ((void*)rpb->iovec, bqo, rpb->iovecsz);
if (rpb->devtyp == BDEV_SDN)
rpb->devtyp = BDEV_SD; /* XXX until driver fixed */
} else {
bzero(rpb, sizeof(struct rpb));
rpb->devtyp = bootregs[0];
rpb->unit = bootregs[3];
rpb->rpb_bootr5 = bootregs[5];
rpb->csrphy = bootregs[2];
rpb->adpphy = bootregs[1]; /* BI node on 8200 */
if (rpb->devtyp != BDEV_HP && vax_cputype == VAX_TYP_750)
rpb->adpphy =
(bootregs[1] == 0xffe000 ? 0xf30000 : 0xf32000);
}
rpb->rpb_base = rpb;
rpb->iovec = (int)bqo;
io = open("/boot.vax", 0);
if (io < 0)
io = open("/boot", 0);
if (io < 0)
asm("halt");
read(io, (void *)&hdr.aout, sizeof(hdr.aout));
if (N_GETMAGIC(hdr.aout) == OMAGIC && N_GETMID(hdr.aout) == MID_VAX) {
vax_load_failure++;
entry = hdr.aout.a_entry;
if (entry < sizeof(hdr.aout))
entry = sizeof(hdr.aout);
read(io, (void *) entry, hdr.aout.a_text + hdr.aout.a_data);
memset((void *) (entry + hdr.aout.a_text + hdr.aout.a_data),
0, hdr.aout.a_bss);
} else if (memcmp(hdr.elf.e_ident, ELFMAG, SELFMAG) == 0) {
Elf32_Phdr ph;
size_t off = sizeof(hdr.elf);
vax_load_failure += 2;
read(io, (caddr_t)(&hdr.elf) + sizeof(hdr.aout),
sizeof(hdr.elf) - sizeof(hdr.aout));
if (hdr.elf.e_machine != EM_VAX || hdr.elf.e_type != ET_EXEC
|| hdr.elf.e_phnum != 1)
goto die;
vax_load_failure++;
entry = hdr.elf.e_entry;
if (hdr.elf.e_phoff != sizeof(hdr.elf))
goto die;
vax_load_failure++;
read(io, &ph, sizeof(ph));
off += sizeof(ph);
if (ph.p_type != PT_LOAD)
goto die;
vax_load_failure++;
while (off < ph.p_offset) {
u_int32_t tmp;
read(io, &tmp, sizeof(tmp));
off += sizeof(tmp);
}
read(io, (void *) ph.p_paddr, ph.p_filesz);
memset((void *) (ph.p_paddr + ph.p_filesz), 0,
ph.p_memsz - ph.p_filesz);
} else {
goto die;
}
hoppabort(entry);
die:
asm("halt");
}
/*
* Write an extremely limited version of a (us)tar filesystem, suitable
* for loading secondary-stage boot loader.
* - Can only load file "boot".
* - Must be the first file on tape.
*/
struct fs_ops file_system[] = {
{ ufs_open, 0, ufs_read, 0, 0, ufs_stat },
{ cd9660_open, 0, cd9660_read, 0, 0, cd9660_stat },
#if 0
{ ustarfs_open, 0, ustarfs_read, 0, 0, ustarfs_stat },
#endif
};
int nfsys = (sizeof(file_system) / sizeof(struct fs_ops));
#if 0
int tar_open(char *path, struct open_file *f);
ssize_t tar_read(struct open_file *f, void *buf, size_t size, size_t *resid);
int
tar_open(path, f)
char *path;
struct open_file *f;
{
char *buf = alloc(512);
bzero(buf, 512);
romstrategy(0, 0, 8192, 512, buf, 0);
if (bcmp(buf, "boot", 5) || bcmp(&buf[257], "ustar", 5))
return EINVAL; /* Not a ustarfs with "boot" first */
return 0;
}
ssize_t
tar_read(f, buf, size, resid)
struct open_file *f;
void *buf;
size_t size;
size_t *resid;
{
romstrategy(0, 0, (8192+512), size, buf, 0);
*resid = size;
return 0; /* XXX */
}
#endif
int
devopen(f, fname, file)
struct open_file *f;
const char *fname;
char **file;
{
*file = (char *)fname;
if (from == FROM750)
return 0;
/*
* Reinit the VMB boot device.
*/
if (bqo->unit_init && (moved++ == 0)) {
int initfn;
initfn = rpb->iovec + bqo->unit_init;
if (rpb->devtyp == BDEV_UDA || rpb->devtyp == BDEV_TK) {
/*
* This reset do not seem to be done in the
* ROM routines, so we have to do it manually.
*/
csr = (struct udadevice *)rpb->csrphy;
csr->udaip = 0;
while ((csr->udasa & MP_STEP1) == 0)
;
}
/*
* AP (R12) have a pointer to the VMB argument list,
* wanted by bqo->unit_init.
*/
unit_init(initfn, rpb, bootregs[12]);
}
return 0;
}
extern struct disklabel romlabel;
int
romstrategy(sc, func, dblk, size, buf, rsize)
void *sc;
int func;
daddr_t dblk;
size_t size;
void *buf;
size_t *rsize;
{
int block = dblk;
int nsize = size;
if (romlabel.d_magic == DISKMAGIC && romlabel.d_magic2 == DISKMAGIC) {
if (romlabel.d_npartitions > 1) {
block += romlabel.d_partitions[0].p_offset;
if (romlabel.d_partitions[0].p_fstype == FS_RAID) {
block += RF_PROTECTED_SECTORS;
}
}
}
if (from == FROMMV) {
romread_uvax(block, size, buf, rpb);
} else /* if (from == FROM750) */ {
while (size > 0) {
if (rpb->devtyp == BDEV_HP)
hpread(block);
else
read750(block, bootregs);
bcopy(0, buf, 512);
size -= 512;
(char *)buf += 512;
block++;
}
}
if (rsize)
*rsize = nsize;
return 0;
}
/*
* The 11/750 boot ROM for Massbus disks doesn't seen to have layout info
* for all RP disks (not RP07 at least) so therefore a very small and dumb
* device driver is used. It assumes that there is a label on the disk
* already that has valid layout info. If there is no label, we can't boot
* anyway.
*/
#define MBA_WCSR(reg, val) \
((void)(*(volatile u_int32_t *)((adpadr) + (reg)) = (val)));
#define MBA_RCSR(reg) \
(*(volatile u_int32_t *)((adpadr) + (reg)))
#define HP_WCSR(reg, val) \
((void)(*(volatile u_int32_t *)((unitadr) + (reg)) = (val)));
#define HP_RCSR(reg) \
(*(volatile u_int32_t *)((unitadr) + (reg)))
void
hpread(int bn)
{
int adpadr = bootregs[1];
int unitadr = adpadr + MUREG(bootregs[3], 0);
u_int cn, sn, tn;
struct disklabel *dp;
extern char start;
dp = (struct disklabel *)(LABELOFFSET + &start);
MBA_WCSR(MAPREG(0), PG_V);
MBA_WCSR(MBA_VAR, 0);
MBA_WCSR(MBA_BC, (~512) + 1);
#ifdef __GNUC__
/*
* Avoid four subroutine calls by using hardware division.
*/
asm("clrl r1;movl %3,r0;ediv %4,r0,%0,%1;movl %1,r0;ediv %5,r0,%2,%1"
: "=g"(cn),"=g"(sn),"=g"(tn)
: "g"(bn),"g"(dp->d_secpercyl),"g"(dp->d_nsectors)
: "r0","r1","cc");
#else
cn = bn / dp->d_secpercyl;
sn = bn % dp->d_secpercyl;
tn = sn / dp->d_nsectors;
sn = sn % dp->d_nsectors;
#endif
HP_WCSR(HP_DC, cn);
HP_WCSR(HP_DA, (tn << 8) | sn);
HP_WCSR(HP_CS1, HPCS_READ);
while (MBA_RCSR(MBA_SR) & MBASR_DTBUSY)
;
return;
}
extern char end[];
static char *top = (char*)end;
void *
alloc(size)
unsigned size;
{
void *ut = top;
top += size;
return ut;
}
void
free(ptr, size)
void *ptr;
unsigned size;
{
}
int
romclose(f)
struct open_file *f;
{
return 0;
}
#ifdef USE_PRINTF
void
putchar(int ch)
{
/*
* On KA88 we may get C-S/C-Q from the console.
* Must obey it.
*/
while (mfpr(PR_RXCS) & GC_DON) {
if ((mfpr(PR_RXDB) & 0x7f) == 19) {
while (1) {
while ((mfpr(PR_RXCS) & GC_DON) == 0)
;
if ((mfpr(PR_RXDB) & 0x7f) == 17)
break;
}
}
}
while ((mfpr(PR_TXCS) & GC_RDY) == 0)
;
mtpr(0, PR_TXCS);
mtpr(ch & 0377, PR_TXDB);
if (ch == 10)
putchar(13);
}
#endif