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

481 lines
11 KiB
C

/* $NetBSD: bootxx.c,v 1.13 1998/03/20 16:36:20 ragge 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 "lib/libsa/stand.h"
#include "lib/libsa/ufs.h"
#include "../include/pte.h"
#include "../include/sid.h"
#include "../include/mtpr.h"
#include "../include/reg.h"
#include "../include/rpb.h"
#include "../mba/mbareg.h"
#include "../mba/hpreg.h"
#define NRSP 1 /* Kludge */
#define NCMD 1 /* Kludge */
#include "../uba/ubareg.h"
#include "../uba/udareg.h"
#include "../mscp/mscp.h"
#include "../mscp/mscpreg.h"
#include "data.h"
#include "vaxstand.h"
#include <a.out.h>
int romstrategy(), romopen();
int command(int, int);
/*
* Boot program... argume passed in r10 and r11 determine whether boot
* stops to ask for system name and which device boot comes from.
*/
volatile u_int devtype, bootdev;
unsigned opendev, boothowto, bootset, memsz;
extern unsigned *bootregs;
extern struct rpb *rpb;
/*
* The boot block are used by 11/750, 8200, MicroVAX II/III, VS2000,
* VS3100/??, VS4000 and VAX6000/???, and only when booting from disk.
*/
Xmain()
{
int io;
char *scbb;
char *new;
char *hej = "/boot";
switch (vax_cputype) {
case VAX_TYP_UV2:
case VAX_TYP_CVAX:
case VAX_TYP_RIGEL:
case VAX_TYP_NVAX:
case VAX_TYP_SOC:
/*
* now relocate rpb/bqo (which are used by ROM-routines)
*/
rpb = (void*)XXRPB;
bcopy ((void*)bootregs[11], rpb, 512);
rpb->rpb_base = rpb;
bqo = (void*)(512+(int)rpb);
bcopy ((void*)rpb->iovec, bqo, rpb->iovecsz);
rpb->iovec = (int)bqo;
bootregs[11] = (int)rpb;
bootdev = rpb->devtyp;
memsz = rpb->pfncnt << 9;
break;
case VAX_8200:
case VAX_750:
bootdev = bootregs[10];
memsz = 0;
break;
default:
nprint(vax_cputype, 10);
sprint(": Unknown CPU type, regs:\n");
for (io = 0; io < 16; io++) {
nprint(bootregs[io], 16);
putchar('\n');
}
asm("halt");
}
bootset = getbootdev();
sprint("\nhowto 0x");
nprint(boothowto, 16);
sprint(", bdev 0x");
nprint(bootdev, 16);
sprint(", booting...");
io = open(hej, 0);
if (io >= 0 && io < SOPEN_MAX) {
copyunix(io);
} else {
sprint("Boot failed, saerrno ");
nprint(errno, 10);
putchar('\n');
}
}
/* ARGSUSED */
copyunix(aio)
{
struct exec x;
register int io = aio, i;
char *addr;
i = read(io, (char *) &x, sizeof(x));
if (i != sizeof(x) || N_BADMAG(x)) {
sprint("Bad format\n");
return;
}
if (N_GETMAGIC(x) == ZMAGIC && lseek(io, N_TXTADDR(x), SEEK_SET) == -1)
goto shread;
if (read(io, (char *) 0x10000, x.a_text) != x.a_text)
goto shread;
addr = (char *) x.a_text;
if (N_GETMAGIC(x) == ZMAGIC || N_GETMAGIC(x) == NMAGIC)
while ((int) addr & CLOFSET)
*addr++ = 0;
if (read(io, addr + 0x10000, x.a_data) != x.a_data)
goto shread;
addr += x.a_data;
bcopy((void *) 0x10000, 0, (int) addr);
for (i = 0; i < x.a_bss; i++)
*addr++ = 0;
for (i = 0; i < 128 * 512; i++) /* slop */
*addr++ = 0;
sprint("done.\n");
hoppabort(x.a_entry, boothowto, bootset);
(*((int (*) ()) x.a_entry)) ();
return;
shread:
sprint("Short read\n");
return;
}
getbootdev()
{
int i, adaptor, controller, unit, partition, retval;
adaptor = controller = unit = partition = 0;
switch (vax_cputype) {
case VAX_TYP_UV2:
case VAX_TYP_CVAX:
adaptor = 0;
controller = ((rpb->csrphy & 017777) == 0xDC)?1:0;
unit = rpb->unit; /* DUC, DUD? */
break;
case VAX_TYP_RIGEL:
unit = rpb->unit;
if (unit > 99)
unit /= 100; /* DKB300 is target 3 */
break;
case VAX_TYP_8SS:
case VAX_TYP_750:
controller = 0; /* XXX Actually massbuss can be on 3 ctlr's */
unit = bootregs[3];
break;
}
switch (B_TYPE(bootdev)) {
case BDEV_HP: /* massbuss boot */
adaptor = (bootregs[1] & 0x6000) >> 17;
break;
case BDEV_UDA: /* UDA50 boot */
if (vax_cputype == VAX_750)
adaptor = (bootregs[1] & 0x40000 ? 0 : 1);
break;
case BDEV_TK: /* TK50 boot */
case BDEV_CNSL: /* Console storage boot */
case BDEV_RD: /* RD/RX on HDC9224 (MV2000) */
controller = 0; /* They are always on ctlr 0 */
break;
case BDEV_ST: /* SCSI-tape on NCR5380 (MV2000) */
case BDEV_SD: /* SCSI-disk on NCR5380 (3100/76) */
/*
* No standalone routines for SCSI support yet.
* Use rom-routines instead!
*/
break;
default:
sprint("Unsupported boot device, trying anyway.\n");
boothowto |= (RB_SINGLE | RB_ASKNAME);
}
return MAKEBOOTDEV(bootdev, adaptor, controller, unit, partition);
}
struct devsw devsw[] = {
SADEV("rom", romstrategy,nullsys,nullsys, noioctl),
};
int ndevs = (sizeof(devsw) / sizeof(devsw[0]));
struct fs_ops file_system[] = {
{ufs_open, ufs_close, ufs_read, ufs_write, ufs_seek, ufs_stat}
};
int nfsys = (sizeof(file_system) / sizeof(struct fs_ops));
struct disklabel lp;
int part_off = 0; /* offset into partition holding /boot */
char io_buf[MAXBSIZE];
volatile struct uda {
struct mscp_1ca uda_ca; /* communications area */
struct mscp uda_rsp; /* response packets */
struct mscp uda_cmd; /* command packets */
} uda;
volatile struct udadevice *csr;
devopen(f, fname, file)
struct open_file *f;
const char *fname;
char **file;
{
extern char start;
char *msg;
int i, err, off;
char line[64];
f->f_dev = &devsw[0];
*file = (char *)fname;
/*
* On uVAX we need to init [T]MSCP ctlr to be able to use it.
*/
if (vax_cputype == VAX_TYP_UV2 || vax_cputype == VAX_TYP_CVAX) {
switch (bootdev) {
case BDEV_UDA: /* MSCP */
case BDEV_TK: /* TMSCP */
csr = (struct udadevice *)rpb->csrphy;
csr->udaip = 0; /* Start init */
while((csr->udasa & MP_STEP1) == 0);
csr->udasa = 0x8000;
while((csr->udasa & MP_STEP2) == 0);
csr->udasa = (short)(((u_int)&uda)&0xffff) + 8;
while((csr->udasa & MP_STEP3) == 0);
csr->udasa = 0x10;
while((csr->udasa & MP_STEP4) == 0);
csr->udasa = 0x0001;
uda.uda_ca.ca_rspdsc =
(int) &uda.uda_rsp.mscp_cmdref;
uda.uda_ca.ca_cmddsc =
(int) &uda.uda_cmd.mscp_cmdref;
if (bootdev == BDEV_TK)
uda.uda_cmd.mscp_vcid = 1;
command(M_OP_SETCTLRC, 0);
uda.uda_cmd.mscp_unit = rpb->unit;
command(M_OP_ONLINE, 0);
}
}
/*
* the disklabel _shall_ be at address LABELOFFSET + RELOC in
* phys memory now, no need at all to reread it again.
* Actually disklabel is only needed when using hp disks,
* but it doesn't hurt to always get it.
*/
if ((bootdev != BDEV_TK) && (bootdev != BDEV_CNSL)) {
msg = getdisklabel(LABELOFFSET + &start, &lp);
if (msg) {
sprint(msg);
putchar('\n');
}
}
return 0;
}
command(cmd, arg)
{
volatile int hej;
uda.uda_cmd.mscp_opcode = cmd;
uda.uda_cmd.mscp_modifier = arg;
uda.uda_cmd.mscp_msglen = MSCP_MSGLEN;
uda.uda_rsp.mscp_msglen = MSCP_MSGLEN;
uda.uda_ca.ca_rspdsc |= MSCP_OWN|MSCP_INT;
uda.uda_ca.ca_cmddsc |= MSCP_OWN|MSCP_INT;
hej = csr->udaip;
while (uda.uda_ca.ca_rspdsc < 0);
}
int curblock = 0;
romstrategy(sc, func, dblk, size, buf, rsize)
void *sc;
int func;
daddr_t dblk;
char *buf;
int size, *rsize;
{
int i;
int block = dblk;
int nsize = size;
switch (vax_cputype) {
/*
* case VAX_TYP_UV2:
* case VAX_TYP_CVAX:
* case VAX_TYP_RIGEL:
*/
default:
switch (bootdev) {
case BDEV_UDA: /* MSCP */
uda.uda_cmd.mscp_seq.seq_lbn = dblk;
uda.uda_cmd.mscp_seq.seq_bytecount = size;
uda.uda_cmd.mscp_seq.seq_buffer = (int)buf;
uda.uda_cmd.mscp_unit = rpb->unit;
command(M_OP_READ, 0);
break;
case BDEV_TK: /* TMSCP */
if (dblk < curblock) {
uda.uda_cmd.mscp_seq.seq_bytecount =
curblock - dblk;
command(M_OP_POS, 12);
} else {
uda.uda_cmd.mscp_seq.seq_bytecount =
dblk - curblock;
command(M_OP_POS, 4);
}
curblock = size/512 + dblk;
for (i = 0 ; i < size/512 ; i++) {
uda.uda_cmd.mscp_seq.seq_lbn = 1;
uda.uda_cmd.mscp_seq.seq_bytecount = 512;
uda.uda_cmd.mscp_seq.seq_buffer =
(int)buf + i * 512;
uda.uda_cmd.mscp_unit = rpb->unit;
command(M_OP_READ, 0);
}
break;
case BDEV_RD:
case BDEV_ST:
case BDEV_SD:
default:
romread_uvax(block, size, buf, bootregs);
break;
}
break;
case VAX_8200:
case VAX_750:
if (bootdev != BDEV_HP) {
while (size > 0) {
while ((read750(block, bootregs) & 0x01) == 0){
sprint("Retrying read bn# ");
nprint(block, 10);
putchar('\n');
}
bcopy(0, buf, 512);
size -= 512;
buf += 512;
block++;
}
} else
hpread(block, size, buf);
break;
}
*rsize = nsize;
return 0;
}
hpread(block, size, buf)
char *buf;
{
volatile struct mba_regs *mr = (void *) bootregs[1];
volatile struct hp_drv *hd = (void*)&mr->mba_md[bootregs[3]];
struct disklabel *dp = &lp;
u_int pfnum, nsize, mapnr, bn, cn, sn, tn;
pfnum = (u_int) buf >> PGSHIFT;
for (mapnr = 0, nsize = size; (nsize + NBPG) > 0; nsize -= NBPG)
*(int *)&mr->mba_map[mapnr++] = PG_V | pfnum++;
mr->mba_var = ((u_int) buf & PGOFSET);
mr->mba_bc = (~size) + 1;
bn = block;
cn = bn / dp->d_secpercyl;
sn = bn % dp->d_secpercyl;
tn = sn / dp->d_nsectors;
sn = sn % dp->d_nsectors;
hd->hp_dc = cn;
hd->hp_da = (tn << 8) | sn;
hd->hp_cs1 = HPCS_READ;
while (mr->mba_sr & MBASR_DTBUSY);
if (mr->mba_sr & MBACR_ABORT){
return 1;
}
return 0;
}
sprint(s)
char *s;
{
while(*s)
putchar(*s++);
}
nprint(nr, base)
{
do {
putchar("0123456789abcdef"[nr % base]);
} while (nr /= base);
}
void
twiddle()
{
static int pos;
putchar("|/-\\"[pos++ & 3]);
putchar('\b');
}