[BACK]Return to main.c CVS log [TXT][DIR] Up to [local] / sys / arch / macppc / stand

Annotation of sys/arch/macppc/stand/main.c, Revision 1.1

1.1     ! nbrk        1: /*     $OpenBSD: main.c,v 1.3 2007/06/24 14:58:12 tom Exp $    */
        !             2: /*     $NetBSD: boot.c,v 1.1 1997/04/16 20:29:17 thorpej Exp $ */
        !             3:
        !             4: /*
        !             5:  * Copyright (c) 1997 Jason R. Thorpe.  All rights reserved.
        !             6:  * Copyright (C) 1995, 1996 Wolfgang Solfrank.
        !             7:  * Copyright (C) 1995, 1996 TooLs GmbH.
        !             8:  * All rights reserved.
        !             9:  *
        !            10:  * ELF support derived from NetBSD/alpha's boot loader, written
        !            11:  * by Christopher G. Demetriou.
        !            12:  *
        !            13:  * Redistribution and use in source and binary forms, with or without
        !            14:  * modification, are permitted provided that the following conditions
        !            15:  * are met:
        !            16:  * 1. Redistributions of source code must retain the above copyright
        !            17:  *    notice, this list of conditions and the following disclaimer.
        !            18:  * 2. Redistributions in binary form must reproduce the above copyright
        !            19:  *    notice, this list of conditions and the following disclaimer in the
        !            20:  *    documentation and/or other materials provided with the distribution.
        !            21:  * 3. All advertising materials mentioning features or use of this software
        !            22:  *    must display the following acknowledgement:
        !            23:  *     This product includes software developed by TooLs GmbH.
        !            24:  * 4. The name of TooLs GmbH may not be used to endorse or promote products
        !            25:  *    derived from this software without specific prior written permission.
        !            26:  *
        !            27:  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
        !            28:  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
        !            29:  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
        !            30:  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
        !            31:  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
        !            32:  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
        !            33:  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
        !            34:  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
        !            35:  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
        !            36:  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
        !            37:  */
        !            38:
        !            39: /*
        !            40:  * First try for the boot code
        !            41:  *
        !            42:  * Input syntax is:
        !            43:  *     [promdev[{:|,}partition]]/[filename] [flags]
        !            44:  */
        !            45:
        !            46: #define        ELFSIZE         32              /* We use 32-bit ELF. */
        !            47:
        !            48: #include <sys/param.h>
        !            49: #include <sys/exec.h>
        !            50: #include <sys/exec_elf.h>
        !            51: #include <sys/reboot.h>
        !            52: #include <sys/disklabel.h>
        !            53:
        !            54: #include <lib/libkern/libkern.h>
        !            55: #include <lib/libsa/stand.h>
        !            56: #include <lib/libsa/loadfile.h>
        !            57: #include <stand/boot/cmd.h>
        !            58:
        !            59:
        !            60: #include <machine/cpu.h>
        !            61:
        !            62: #include <macppc/stand/ofdev.h>
        !            63: #include <macppc/stand/openfirm.h>
        !            64:
        !            65: char bootdev[128];
        !            66: int boothowto;
        !            67: int debug;
        !            68:
        !            69:
        !            70: void
        !            71: get_alt_bootdev(char *, size_t, char *, size_t);
        !            72:
        !            73: static void
        !            74: prom2boot(char *dev)
        !            75: {
        !            76:        char *cp, *lp = 0;
        !            77:
        !            78:        for (cp = dev; *cp; cp++)
        !            79:                if (*cp == ':')
        !            80:                        lp = cp;
        !            81:        if (!lp)
        !            82:                lp = cp;
        !            83:        *lp = 0;
        !            84: }
        !            85:
        !            86: static void
        !            87: parseargs(char *str, int *howtop)
        !            88: {
        !            89:        char *cp;
        !            90:
        !            91:        /* Allow user to drop back to the PROM. */
        !            92:        if (strcmp(str, "exit") == 0)
        !            93:                _rtt();
        !            94:
        !            95:        *howtop = 0;
        !            96:        if (str[0] == '\0')
        !            97:                return;
        !            98:
        !            99:        cp = str;
        !           100:        while (*cp != 0) {
        !           101:                /* check for - */
        !           102:                if (*cp == '-')
        !           103:                        break;  /* start of options found */
        !           104:
        !           105:                while (*cp != 0 && *cp != ' ')
        !           106:                        cp++;   /* character in the middle of the name, skip */
        !           107:
        !           108:                while (*cp == ' ')
        !           109:                        *cp++ = 0;
        !           110:        }
        !           111:        if (!*cp)
        !           112:                return;
        !           113:
        !           114:        *cp++ = 0;
        !           115:        while (*cp) {
        !           116:                switch (*cp++) {
        !           117:                case 'a':
        !           118:                        *howtop |= RB_ASKNAME;
        !           119:                        break;
        !           120:                case 'c':
        !           121:                        *howtop |= RB_CONFIG;
        !           122:                        break;
        !           123:                case 's':
        !           124:                        *howtop |= RB_SINGLE;
        !           125:                        break;
        !           126:                case 'd':
        !           127:                        *howtop |= RB_KDB;
        !           128:                        debug = 1;
        !           129:                        break;
        !           130:                }
        !           131:        }
        !           132: }
        !           133:
        !           134: static void
        !           135: chain(void (*entry)(), char *args, void *ssym, void *esym)
        !           136: {
        !           137:        extern char end[];
        !           138:        int l, machine_tag;
        !           139:
        !           140:        freeall();
        !           141:
        !           142:        /*
        !           143:         * Stash pointer to end of symbol table after the argument
        !           144:         * strings.
        !           145:         */
        !           146:        l = strlen(args) + 1;
        !           147:        bcopy(&ssym, args + l, sizeof(ssym));
        !           148:        l += sizeof(ssym);
        !           149:        bcopy(&esym, args + l, sizeof(esym));
        !           150:        l += sizeof(esym);
        !           151:
        !           152: #ifdef __notyet__
        !           153:        /*
        !           154:         * Tell the kernel we're an OpenFirmware system.
        !           155:         */
        !           156:        machine_tag = POWERPC_MACHINE_OPENFIRMWARE;
        !           157:        bcopy(&machine_tag, args + l, sizeof(machine_tag));
        !           158:        l += sizeof(machine_tag);
        !           159: #endif
        !           160:
        !           161:        OF_chain((void *)RELOC, end - (char *)RELOC, entry, args, l);
        !           162:        panic("chain");
        !           163: }
        !           164:
        !           165: /*
        !           166:  * XXX This limits the maximum size of the (uncompressed) bsd.rd to a
        !           167:  * little under 11MB.
        !           168:  */
        !           169: #define CLAIM_LIMIT    0x00c00000
        !           170:
        !           171: char bootline[512];
        !           172:
        !           173: extern char *kernelfile;
        !           174: int
        !           175: main()
        !           176: {
        !           177:        int chosen;
        !           178:        u_long marks[MARK_MAX];
        !           179:        int fd;
        !           180:
        !           181:
        !           182:        /*
        !           183:         * Get the boot arguments from Openfirmware
        !           184:         */
        !           185:        if ((chosen = OF_finddevice("/chosen")) == -1 ||
        !           186:            OF_getprop(chosen, "bootpath", bootdev, sizeof bootdev) < 0 ||
        !           187:            OF_getprop(chosen, "bootargs", bootline, sizeof bootline) < 0) {
        !           188:                printf("Invalid Openfirmware environment\n");
        !           189:                exit();
        !           190:        }
        !           191:        prom2boot(bootdev);
        !           192:        get_alt_bootdev(bootdev, sizeof(bootdev), bootline, sizeof(bootline));
        !           193:        if (bootline[0] != '\0')
        !           194:                kernelfile = bootline;
        !           195:
        !           196:        OF_claim((void *)0x00100000, CLAIM_LIMIT, 0); /* XXX */
        !           197:        boot(0);
        !           198:        return 0;
        !           199: }
        !           200:
        !           201: void
        !           202: get_alt_bootdev(char *dev, size_t devsz, char *line, size_t linesz)
        !           203: {
        !           204:        char *p;
        !           205:        int len;
        !           206:        /*
        !           207:         * if the kernel image specified contains a ':' it is
        !           208:         * [device]:[kernel], so seperate the two fields.
        !           209:         */
        !           210:        p = strrchr(line, ':');
        !           211:        if (p == NULL)
        !           212:                return;
        !           213:        /* user specified boot device for kernel */
        !           214:        len = p - line + 1; /* str len plus nil */
        !           215:        strlcpy(dev, line, len > devsz ? devsz : len);
        !           216:
        !           217:        strlcpy(line, p+1, linesz); /* rest of string ater ':' */
        !           218: }
        !           219:
        !           220:
        !           221: void
        !           222: devboot(dev_t dev, char *p)
        !           223: {
        !           224:        strlcpy(p, bootdev, BOOTDEVLEN);
        !           225: }
        !           226:
        !           227: run_loadfile(u_long *marks, int howto)
        !           228: {
        !           229:        char bootline[512];             /* Should check size? */
        !           230:        u_int32_t entry;
        !           231:        char *cp;
        !           232:        void *ssym, *esym;
        !           233:
        !           234:        strlcpy(bootline, opened_name, sizeof bootline);
        !           235:        cp = bootline + strlen(bootline);
        !           236:        *cp++ = ' ';
        !           237:         *cp = '-';
        !           238:         if (howto & RB_ASKNAME)
        !           239:                 *++cp = 'a';
        !           240:         if (howto & RB_CONFIG)
        !           241:                 *++cp = 'c';
        !           242:         if (howto & RB_SINGLE)
        !           243:                 *++cp = 's';
        !           244:         if (howto & RB_KDB)
        !           245:                 *++cp = 'd';
        !           246:         if (*cp == '-')
        !           247:                *--cp = 0;
        !           248:        else
        !           249:                *++cp = 0;
        !           250:
        !           251:        entry = marks[MARK_ENTRY];
        !           252:        ssym = (void *)marks[MARK_SYM];
        !           253:        esym = (void *)marks[MARK_END];
        !           254:        {
        !           255:                u_int32_t lastpage;
        !           256:                lastpage = roundup(marks[MARK_END], NBPG);
        !           257:                OF_release((void*)lastpage, CLAIM_LIMIT - lastpage);
        !           258:        }
        !           259:
        !           260:        chain((void *)entry, bootline, ssym, esym);
        !           261:
        !           262:        _rtt();
        !           263:        return 0;
        !           264:
        !           265: }
        !           266:
        !           267: int
        !           268: cnspeed(dev_t dev, int sp)
        !           269: {
        !           270:        return CONSPEED;
        !           271: }
        !           272:
        !           273: char ttyname_buf[8];
        !           274:
        !           275: char *
        !           276: ttyname(int fd)
        !           277: {
        !           278:         snprintf(ttyname_buf, sizeof ttyname_buf, "ofc0");
        !           279:
        !           280: }
        !           281:
        !           282: dev_t
        !           283: ttydev(char *name)
        !           284: {
        !           285:        return makedev(0,0);
        !           286: }

CVSweb