Return to bootxx.c CVS log

Up to [local] / sys / arch / alpha / stand

Annotation of sys/arch/alpha/stand/bootxx.c, Revision 1.1

1.1     ! nbrk        1: /*     $OpenBSD: bootxx.c,v 1.10 2004/07/05 19:59:17 deraadt Exp $     */
        !             2: /*     $NetBSD: bootxx.c,v 1.4 1997/01/18 00:28:59 cgd Exp $   */
        !             3:
        !             4: /*
        !             5:  * Copyright (c) 1995 Carnegie-Mellon University.
        !             6:  * All rights reserved.
        !             7:  *
        !             8:  * Author: Chris G. Demetriou
        !             9:  *
        !            10:  * Permission to use, copy, modify and distribute this software and
        !            11:  * its documentation is hereby granted, provided that both the copyright
        !            12:  * notice and this permission notice appear in all copies of the
        !            13:  * software, derivative works or modified versions, and any portions
        !            14:  * thereof, and that both notices appear in supporting documentation.
        !            15:  *
        !            16:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
        !            17:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
        !            18:  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
        !            19:  *
        !            20:  * Carnegie Mellon requests users of this software to return to
        !            21:  *
        !            22:  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
        !            23:  *  School of Computer Science
        !            24:  *  Carnegie Mellon University
        !            25:  *  Pittsburgh PA 15213-3890
        !            26:  *
        !            27:  * any improvements or extensions that they make and grant Carnegie the
        !            28:  * rights to redistribute these changes.
        !            29:  */
        !            30:
        !            31: #include <sys/param.h>
        !            32: #include <machine/rpb.h>
        !            33: #include <machine/prom.h>
        !            34:
        !            35: #include "bbinfo.h"
        !            36:
        !            37: extern _end, start;
        !            38:
        !            39: struct bbinfoloc desc = {
        !            40:        0xbabefacedeadbeef,
        !            41:        (u_int64_t)&start,
        !            42:        (u_int64_t)&_end,
        !            43:        { 0, },
        !            44:        0xdeadbeeffacebabe
        !            45: };
        !            46:
        !            47: int
        !            48: open_dev(fd)
        !            49:        int *fd;
        !            50: {
        !            51:        prom_return_t ret;
        !            52:        char devname[64];
        !            53:        int devlen;
        !            54:
        !            55:        /*
        !            56:         * XXX
        !            57:          * We don't know what device names look like yet,
        !            58:          * so we can't change them.
        !            59:          */
        !            60:         ret.bits = prom_getenv(PROM_E_BOOTED_DEV, devname, sizeof(devname));
        !            61:         devlen = ret.u.retval;
        !            62:
        !            63:         ret.bits = prom_open(devname, devlen);
        !            64:         if (ret.u.status)
        !            65:                 return 0;
        !            66:
        !            67:        *fd = ret.u.retval;
        !            68:
        !            69:        return 1;
        !            70: }
        !            71:
        !            72: int
        !            73: load_file(bbinfop, loadaddr)
        !            74:        struct bbinfo *bbinfop;
        !            75:        char *loadaddr;
        !            76: {
        !            77:        prom_return_t ret;
        !            78:        int32_t cksum, *int32p;
        !            79:        int i, n, fd, rv;
        !            80:        char *cp;
        !            81:
        !            82:        if (bbinfop->nblocks <= 0) {
        !            83:                puts("invalid number of blocks in boot program description\n");
        !            84:                return 0;
        !            85:        }
        !            86:        if (bbinfop->bsize < DEV_BSIZE || bbinfop->bsize > MAXBSIZE) {
        !            87:                puts("invalid block size in boot program description\n");
        !            88:                return 0;
        !            89:        }
        !            90:
        !            91:        int32p = (int32_t *)&_end;
        !            92:        n = bbinfop->nblocks +
        !            93:            (sizeof(*bbinfop) / sizeof(bbinfop->blocks[0])) - 1;
        !            94:        if ((long)&_end - (long)&start + sizeof(bbinfop->blocks[0]) * n >
        !            95:            15 * 512) {
        !            96:                puts("way too many blocks\n");
        !            97:                return 0;
        !            98:        }
        !            99:
        !           100:        for (i = 0, cksum = 0; i < n; i++)
        !           101:                cksum += *int32p++;
        !           102:        if (cksum != 0) {
        !           103:                puts("invalid checksum in boot program description\n");
        !           104:                return 0;
        !           105:        }
        !           106:
        !           107:        if (!open_dev(&fd)) {
        !           108:                puts("couldn't open disk device\n");
        !           109:                return 0;
        !           110:        }
        !           111:
        !           112:        cp = loadaddr;
        !           113:        rv = 1;
        !           114:        for (i = 0; i < bbinfop->nblocks; i++) {
        !           115: puts(".");
        !           116:                ret.bits = prom_read(fd, bbinfop->bsize, cp,
        !           117:                    bbinfop->blocks[i]);
        !           118: puts("\b");
        !           119:                if (ret.u.status) {
        !           120:                        rv = 0;
        !           121:                        puts("BLOCK READ ERROR!\n");
        !           122:                        break;
        !           123:                }
        !           124:                cp += bbinfop->bsize;
        !           125:        }
        !           126:        prom_close(fd);
        !           127:
        !           128:        return (rv);
        !           129: }
        !           130:
        !           131: int
        !           132: main()
        !           133: {
        !           134:        struct bbinfo *bbinfop;
        !           135:        char *loadaddr;
        !           136:        void (*entry)(void);
        !           137:
        !           138:        /* Init prom callback vector. */
        !           139:        init_prom_calls();
        !           140:
        !           141:        puts("\nOpenBSD/Alpha Primary Boot\n");
        !           142:
        !           143:        bbinfop = (struct bbinfo *)&_end;
        !           144:        loadaddr = (char *)SECONDARY_LOAD_ADDRESS;
        !           145:        if (!load_file(bbinfop, loadaddr)) {
        !           146:                puts("\nLOAD FAILED!\n\n");
        !           147:                return;
        !           148:        }
        !           149:
        !           150: #if 0
        !           151:        puts("Jumping to entry point...\n");
        !           152: #endif
        !           153:        entry = (void (*)())loadaddr;
        !           154:        (*entry)();
        !           155:        puts("SECONDARY BOOT BLOCK RETURNED!\n");
        !           156: }