Home | History | Annotate | Line # | Download | only in xxboot
bootxx.c revision 1.1 
      1 /* $NetBSD: bootxx.c,v 1.1 1999/03/06 16:36:06 ragge Exp $ */
      2 /*-
      3  * Copyright (c) 1982, 1986 The Regents of the University of California.
      4  * All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  * 3. All advertising materials mentioning features or use of this software
     15  *    must display the following acknowledgement:
     16  *	This product includes software developed by the University of
     17  *	California, Berkeley and its contributors.
     18  * 4. Neither the name of the University nor the names of its contributors
     19  *    may be used to endorse or promote products derived from this software
     20  *    without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32  * SUCH DAMAGE.
     33  *
     34  *	@(#)boot.c	7.15 (Berkeley) 5/4/91
     35  */
     36 
     37 #include "sys/param.h"
     38 #include "sys/reboot.h"
     39 #include "sys/disklabel.h"
     40 
     41 #include "lib/libsa/stand.h"
     42 #include "lib/libsa/ufs.h"
     43 
     44 #include "../include/pte.h"
     45 #include "../include/sid.h"
     46 #include "../include/mtpr.h"
     47 #include "../include/reg.h"
     48 #include "../include/rpb.h"
     49 
     50 #include "../mba/mbareg.h"
     51 #include "../mba/hpreg.h"
     52 
     53 #define NRSP 1 /* Kludge */
     54 #define NCMD 1 /* Kludge */
     55 
     56 #include "../uba/ubareg.h"
     57 #include "../uba/udareg.h"
     58 
     59 #include "../mscp/mscp.h"
     60 #include "../mscp/mscpreg.h"
     61 
     62 #include <a.out.h>
     63 
     64 int	command(int, int);
     65 
     66 /*
     67  * Boot program... argume passed in r10 and r11 determine whether boot
     68  * stops to ask for system name and which device boot comes from.
     69  */
     70 
     71 volatile u_int  devtype, bootdev;
     72 unsigned        opendev, boothowto, bootset, memsz;
     73 
     74 unsigned *bootregs;
     75 struct	rpb *rpb;
     76 int	vax_cputype;
     77 int	mtpr_cons = 0;
     78 
     79 /*
     80  * The boot block are used by 11/750, 8200, MicroVAX II/III, VS2000,
     81  * VS3100/??, VS4000 and VAX6000/???, and only when booting from disk.
     82  */
     83 Xmain()
     84 {
     85 	int io;
     86 	char *scbb;
     87 	char *new, *bqo;
     88 	char *hej = "/boot";
     89 
     90 	vax_cputype = (mfpr(PR_SID) >> 24) & 0xFF;
     91 	if (vax_cputype < VAX_TYP_UV2)
     92 		mtpr_cons++;
     93 
     94         switch (vax_cputype) {
     95 
     96         case VAX_TYP_UV2:
     97         case VAX_TYP_CVAX:
     98 	case VAX_TYP_RIGEL:
     99 	case VAX_TYP_NVAX:
    100 	case VAX_TYP_SOC:
    101 		/*
    102 		 * now relocate rpb/bqo (which are used by ROM-routines)
    103 		 */
    104 		rpb = (void*)XXRPB;
    105 		bcopy ((void*)bootregs[11], rpb, 512);
    106 		rpb->rpb_base = rpb;
    107 		bqo = (void*)(512+(int)rpb);
    108 		bcopy ((void*)rpb->iovec, bqo, rpb->iovecsz);
    109 		rpb->iovec = (int)bqo;
    110 		bootregs[11] = (int)rpb;
    111 		bootdev = rpb->devtyp;
    112 		memsz = rpb->pfncnt << 9;
    113 
    114                 break;
    115 	case VAX_8200:
    116         case VAX_750:
    117 		bootdev = bootregs[10];
    118 		memsz = 0;
    119 
    120                 break;
    121 	default:
    122 		nprint(vax_cputype, 10);
    123 		sprint(": Unknown CPU type, regs:\n");
    124 		for (io = 0; io < 16; io++) {
    125 			nprint(bootregs[io], 16);
    126 			putchar('\n');
    127 		}
    128 		asm("halt");
    129         }
    130 
    131 	bootset = getbootdev();
    132 
    133 	sprint("\nhowto 0x");
    134 	nprint(boothowto, 16);
    135 	sprint(", bdev 0x");
    136 	nprint(bootdev, 16);
    137 	sprint(", booting...");
    138 	io = open(hej, 0);
    139 
    140 	if (io >= 0 && io < SOPEN_MAX) {
    141 		copyunix(io);
    142 	} else {
    143 		sprint("Boot failed, saerrno ");
    144 		nprint(errno, 10);
    145 		putchar('\n');
    146 	}
    147 }
    148 
    149 /* ARGSUSED */
    150 copyunix(aio)
    151 {
    152 	struct exec     x;
    153 	register int    io = aio, i;
    154 	char           *addr;
    155 
    156 	i = read(io, (char *) &x, sizeof(x));
    157 	if (i != sizeof(x) || N_BADMAG(x)) {
    158 		sprint("Bad format\n");
    159 		return;
    160 	}
    161 
    162 	if (N_GETMAGIC(x) == ZMAGIC && lseek(io, N_TXTADDR(x), SEEK_SET) == -1)
    163 		goto shread;
    164 	if (read(io, (char *) 0x10000, x.a_text) != x.a_text)
    165 		goto shread;
    166 	addr = (char *) x.a_text;
    167 	if (N_GETMAGIC(x) == ZMAGIC || N_GETMAGIC(x) == NMAGIC)
    168 		while ((int) addr & CLOFSET)
    169 			*addr++ = 0;
    170 
    171 	if (read(io, addr + 0x10000, x.a_data) != x.a_data)
    172 		goto shread;
    173 	addr += x.a_data;
    174 	bcopy((void *) 0x10000, 0, (int) addr);
    175 
    176 	for (i = 0; i < x.a_bss; i++)
    177 		*addr++ = 0;
    178 	for (i = 0; i < 128 * 512; i++)	/* slop */
    179 		*addr++ = 0;
    180 	sprint("done.\n");
    181 	hoppabort(x.a_entry, boothowto, bootset);
    182 	(*((int (*) ()) x.a_entry)) ();
    183 	return;
    184 shread:
    185 	sprint("Short read\n");
    186 	return;
    187 }
    188 
    189 getbootdev()
    190 {
    191 	int i, adaptor, controller, unit, partition, retval;
    192 
    193 	adaptor = controller = unit = partition = 0;
    194 
    195 	switch (vax_cputype) {
    196 	case VAX_TYP_UV2:
    197 	case VAX_TYP_CVAX:
    198 		adaptor = 0;
    199 		controller = ((rpb->csrphy & 017777) == 0xDC)?1:0;
    200 		unit = rpb->unit;			/* DUC, DUD? */
    201 
    202 		break;
    203 
    204 	case VAX_TYP_RIGEL:
    205 		unit = rpb->unit;
    206 		if (unit > 99)
    207 			unit /= 100;		/* DKB300 is target 3 */
    208 		break;
    209 
    210 
    211 	case VAX_TYP_8SS:
    212 		controller = bootregs[1];
    213 		unit = bootregs[3];
    214 		break;
    215 
    216 	case VAX_TYP_750:
    217 		controller = 0;	/* XXX Actually massbuss can be on 3 ctlr's */
    218 		unit = bootregs[3];
    219 		break;
    220 	}
    221 
    222 	switch (B_TYPE(bootdev)) {
    223 	case BDEV_HP:			/* massbuss boot */
    224 		adaptor = (bootregs[1] & 0x6000) >> 17;
    225 		break;
    226 
    227 	case BDEV_UDA:		/* UDA50 boot */
    228 		if (vax_cputype == VAX_750)
    229 			adaptor = (bootregs[1] & 0x40000 ? 0 : 1);
    230 		break;
    231 
    232 	case BDEV_TK:		/* TK50 boot */
    233 	case BDEV_CNSL:		/* Console storage boot */
    234 	case BDEV_RD:		/* RD/RX on HDC9224 (MV2000) */
    235 		controller = 0; /* They are always on ctlr 0 */
    236 		break;
    237 
    238 	case BDEV_KDB:		/* DSA disk on KDB50 (VAXBI VAXen) */
    239 		bootdev = (bootdev & ~B_TYPEMASK) | BDEV_UDA;
    240 		break;
    241 
    242 	case BDEV_ST:		/* SCSI-tape on NCR5380 (MV2000) */
    243 	case BDEV_SD:		/* SCSI-disk on NCR5380 (3100/76) */
    244 		/*
    245 		 * No standalone routines for SCSI support yet.
    246 		 * Use rom-routines instead!
    247 		 */
    248 		break;
    249 
    250 	default:
    251 		sprint("Unsupported boot device, trying anyway.\n");
    252 		boothowto |= (RB_SINGLE | RB_ASKNAME);
    253 	}
    254 	return MAKEBOOTDEV(bootdev, adaptor, controller, unit, partition);
    255 }
    256 
    257 int     romstrategy __P((void *, int, daddr_t, size_t, void *, size_t *));
    258 
    259 struct devsw    devsw[] = {
    260 	{"rom", romstrategy, (int(*)(struct open_file *, ...))null_open,
    261 	    null_close, noioctl,},
    262 };
    263 
    264 int             ndevs = (sizeof(devsw) / sizeof(devsw[0]));
    265 
    266 struct fs_ops   file_system[] = {
    267 	{ufs_open, ufs_close, ufs_read, ufs_write, ufs_seek, ufs_stat}
    268 };
    269 
    270 int             nfsys = (sizeof(file_system) / sizeof(struct fs_ops));
    271 
    272 struct disklabel lp;
    273 int part_off = 0;		/* offset into partition holding /boot */
    274 char io_buf[MAXBSIZE];
    275 volatile struct uda {
    276 	struct  mscp_1ca uda_ca;           /* communications area */
    277 	struct  mscp uda_rsp;     /* response packets */
    278 	struct  mscp uda_cmd;     /* command packets */
    279 } uda;
    280 volatile struct udadevice *csr;
    281 
    282 devopen(f, fname, file)
    283 	struct open_file *f;
    284 	const char    *fname;
    285 	char          **file;
    286 {
    287 	extern char	start;
    288 	char           *msg;
    289 	int		i, err, off;
    290 	char		line[64];
    291 
    292 	f->f_dev = &devsw[0];
    293 	*file = (char *)fname;
    294 
    295 	/*
    296 	 * On uVAX we need to init [T]MSCP ctlr to be able to use it.
    297 	 */
    298 	if (vax_cputype == VAX_TYP_UV2 || vax_cputype == VAX_TYP_CVAX) {
    299 		switch (bootdev) {
    300 		case BDEV_UDA:	/* MSCP */
    301 		case BDEV_TK:	/* TMSCP */
    302 			csr = (struct udadevice *)rpb->csrphy;
    303 
    304 			csr->udaip = 0; /* Start init */
    305 			while((csr->udasa & MP_STEP1) == 0);
    306 			csr->udasa = 0x8000;
    307 			while((csr->udasa & MP_STEP2) == 0);
    308 			csr->udasa = (short)(((u_int)&uda)&0xffff) + 8;
    309 			while((csr->udasa & MP_STEP3) == 0);
    310 			csr->udasa = 0x10;
    311 			while((csr->udasa & MP_STEP4) == 0);
    312 			csr->udasa = 0x0001;
    313 
    314 			uda.uda_ca.ca_rspdsc =
    315 			    (int) &uda.uda_rsp.mscp_cmdref;
    316 			uda.uda_ca.ca_cmddsc =
    317 			    (int) &uda.uda_cmd.mscp_cmdref;
    318 			if (bootdev == BDEV_TK)
    319 				uda.uda_cmd.mscp_vcid = 1;
    320 			command(M_OP_SETCTLRC, 0);
    321 			uda.uda_cmd.mscp_unit = rpb->unit;
    322 			command(M_OP_ONLINE, 0);
    323 		}
    324 	}
    325 
    326 	/*
    327 	 * the disklabel _shall_ be at address LABELOFFSET + RELOC in
    328 	 * phys memory now, no need at all to reread it again.
    329 	 * Actually disklabel is only needed when using hp disks,
    330 	 * but it doesn't hurt to always get it.
    331 	 */
    332 	if ((bootdev != BDEV_TK) && (bootdev != BDEV_CNSL)) {
    333 		msg = getdisklabel(LABELOFFSET + &start, &lp);
    334 		if (msg) {
    335 			sprint(msg);
    336 			putchar('\n');
    337 		}
    338 	}
    339 	return 0;
    340 }
    341 
    342 command(cmd, arg)
    343 {
    344 	volatile int hej;
    345 
    346 	uda.uda_cmd.mscp_opcode = cmd;
    347 	uda.uda_cmd.mscp_modifier = arg;
    348 
    349 	uda.uda_cmd.mscp_msglen = MSCP_MSGLEN;
    350 	uda.uda_rsp.mscp_msglen = MSCP_MSGLEN;
    351 	uda.uda_ca.ca_rspdsc |= MSCP_OWN|MSCP_INT;
    352 	uda.uda_ca.ca_cmddsc |= MSCP_OWN|MSCP_INT;
    353 	hej = csr->udaip;
    354 	while (uda.uda_ca.ca_rspdsc < 0);
    355 
    356 }
    357 
    358 int curblock = 0;
    359 
    360 romstrategy(sc, func, dblk, size, buf, rsize)
    361 	void    *sc;
    362 	int     func;
    363 	daddr_t dblk;
    364 	size_t	size;
    365 	void    *buf;
    366 	size_t	*rsize;
    367 {
    368 	int i;
    369 	int	block = dblk;
    370 	int     nsize = size;
    371 
    372 	switch (vax_cputype) {
    373 	/*
    374 	 * case VAX_TYP_UV2:
    375 	 * case VAX_TYP_CVAX:
    376 	 * case VAX_TYP_RIGEL:
    377 	 */
    378 	default:
    379 		switch (bootdev) {
    380 
    381 		case BDEV_UDA: /* MSCP */
    382 			uda.uda_cmd.mscp_seq.seq_lbn = dblk;
    383 			uda.uda_cmd.mscp_seq.seq_bytecount = size;
    384 			uda.uda_cmd.mscp_seq.seq_buffer = (int)buf;
    385 			uda.uda_cmd.mscp_unit = rpb->unit;
    386 			command(M_OP_READ, 0);
    387 			break;
    388 
    389 		case BDEV_TK: /* TMSCP */
    390 			if (dblk < curblock) {
    391 				uda.uda_cmd.mscp_seq.seq_bytecount =
    392 				    curblock - dblk;
    393 				command(M_OP_POS, 12);
    394 			} else {
    395 				uda.uda_cmd.mscp_seq.seq_bytecount =
    396 				    dblk - curblock;
    397 				command(M_OP_POS, 4);
    398 			}
    399 			curblock = size/512 + dblk;
    400 			for (i = 0 ; i < size/512 ; i++) {
    401 				uda.uda_cmd.mscp_seq.seq_lbn = 1;
    402 				uda.uda_cmd.mscp_seq.seq_bytecount = 512;
    403 				uda.uda_cmd.mscp_seq.seq_buffer =
    404 				    (int)buf + i * 512;
    405 				uda.uda_cmd.mscp_unit = rpb->unit;
    406 				command(M_OP_READ, 0);
    407 			}
    408 			break;
    409 		case BDEV_RD:
    410 		case BDEV_ST:
    411 		case BDEV_SD:
    412 
    413 		default:
    414 			romread_uvax(block, size, buf, bootregs);
    415 			break;
    416 
    417 		}
    418 		break;
    419 
    420 	case VAX_8200:
    421 	case VAX_750:
    422 		if (bootdev != BDEV_HP) {
    423 			while (size > 0) {
    424 				while ((read750(block, bootregs) & 0x01) == 0){
    425 					sprint("Retrying read bn# ");
    426 					nprint(block, 10);
    427 					putchar('\n');
    428 				}
    429 				bcopy(0, buf, 512);
    430 				size -= 512;
    431 				buf += 512;
    432 				block++;
    433 			}
    434 		} else
    435 			hpread(block, size, buf);
    436 		break;
    437 	}
    438 
    439 	*rsize = nsize;
    440 	return 0;
    441 }
    442 
    443 hpread(block, size, buf)
    444 	char           *buf;
    445 {
    446 	volatile struct mba_regs *mr = (void *) bootregs[1];
    447 	volatile struct hp_drv *hd = (void*)&mr->mba_md[bootregs[3]];
    448 	struct disklabel *dp = &lp;
    449 	u_int           pfnum, nsize, mapnr, bn, cn, sn, tn;
    450 
    451 	pfnum = (u_int) buf >> PGSHIFT;
    452 
    453 	for (mapnr = 0, nsize = size; (nsize + NBPG) > 0; nsize -= NBPG)
    454 		*(int *)&mr->mba_map[mapnr++] = PG_V | pfnum++;
    455 	mr->mba_var = ((u_int) buf & PGOFSET);
    456 	mr->mba_bc = (~size) + 1;
    457 	bn = block;
    458 	cn = bn / dp->d_secpercyl;
    459 	sn = bn % dp->d_secpercyl;
    460 	tn = sn / dp->d_nsectors;
    461 	sn = sn % dp->d_nsectors;
    462 	hd->hp_dc = cn;
    463 	hd->hp_da = (tn << 8) | sn;
    464 	hd->hp_cs1 = HPCS_READ;
    465 	while (mr->mba_sr & MBASR_DTBUSY);
    466 	if (mr->mba_sr & MBACR_ABORT){
    467 		return 1;
    468 	}
    469 	return 0;
    470 }
    471 
    472 sprint(s)
    473 	char *s;
    474 {
    475 	while(*s)
    476 		putchar(*s++);
    477 }
    478 
    479 nprint(nr, base)
    480 {
    481 
    482 	do {
    483 		putchar("0123456789abcdef"[nr % base]);
    484 	} while (nr /= base);
    485 }
    486 
    487 void
    488 twiddle()
    489 {
    490         static int pos;
    491 
    492         putchar("|/-\\"[pos++ & 3]);
    493         putchar('\b');
    494 }
    495 
    496 void
    497 putchar(c)
    498 	int c;
    499 {
    500 	if (mtpr_cons) {
    501 		while ((mfpr(PR_TXCS) & 0x80) == 0)  /* Wait until xmit ready */
    502 			;
    503         	mtpr(c, PR_TXDB);
    504 	}
    505 }
    506