[BACK]Return to autoconf.c CVS log [TXT][DIR] Up to [local] / sys / arch / mac68k / mac68k

Annotation of sys/arch/mac68k/mac68k/autoconf.c, Revision 1.1

1.1     ! nbrk        1: /*     $OpenBSD: autoconf.c,v 1.30 2007/06/01 19:25:10 deraadt Exp $   */
        !             2: /*     $NetBSD: autoconf.c,v 1.38 1996/12/18 05:46:09 scottr Exp $     */
        !             3:
        !             4: /*
        !             5:  * Copyright (c) 1992, 1993
        !             6:  *     The Regents of the University of California.  All rights reserved.
        !             7:  *
        !             8:  * This software was developed by the Computer Systems Engineering group
        !             9:  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
        !            10:  * contributed to Berkeley.
        !            11:  *
        !            12:  * All advertising materials mentioning features or use of this software
        !            13:  * must display the following acknowledgement:
        !            14:  *     This product includes software developed by the University of
        !            15:  *     California, Lawrence Berkeley Laboratory.
        !            16:  *
        !            17:  * Redistribution and use in source and binary forms, with or without
        !            18:  * modification, are permitted provided that the following conditions
        !            19:  * are met:
        !            20:  * 1. Redistributions of source code must retain the above copyright
        !            21:  *    notice, this list of conditions and the following disclaimer.
        !            22:  * 2. Redistributions in binary form must reproduce the above copyright
        !            23:  *    notice, this list of conditions and the following disclaimer in the
        !            24:  *    documentation and/or other materials provided with the distribution.
        !            25:  * 3. Neither the name of the University nor the names of its contributors
        !            26:  *    may be used to endorse or promote products derived from this software
        !            27:  *    without specific prior written permission.
        !            28:  *
        !            29:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            30:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            31:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            32:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            33:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            34:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            35:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            36:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            37:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            38:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            39:  * SUCH DAMAGE.
        !            40:  *
        !            41:  *     @(#)autoconf.c  8.4 (Berkeley) 10/1/93
        !            42:  */
        !            43:
        !            44: /*
        !            45:  * Setup the system to run on the current machine.
        !            46:  *
        !            47:  * cpu_configure() is called at boot time.  Available
        !            48:  * devices are determined (from possibilities mentioned in ioconf.c),
        !            49:  * and the drivers are initialized.
        !            50:  */
        !            51:
        !            52: #include <sys/param.h>
        !            53: #include <sys/systm.h>
        !            54: #include <sys/buf.h>
        !            55: #include <sys/disklabel.h>
        !            56: #include <sys/conf.h>
        !            57: #include <sys/reboot.h>
        !            58: #include <sys/device.h>
        !            59: #include <sys/disk.h>
        !            60:
        !            61: #include <dev/cons.h>
        !            62:
        !            63: #include <machine/autoconf.h>
        !            64: #include <machine/viareg.h>
        !            65:
        !            66: #include <scsi/scsi_all.h>
        !            67: #include <scsi/scsiconf.h>
        !            68:
        !            69: int target_to_unit(u_long, u_long, u_long);
        !            70: void   findbootdev(void);
        !            71:
        !            72: struct device  *booted_device;
        !            73: int            booted_partition;
        !            74: dev_t          bootdev;
        !            75:
        !            76: /*
        !            77:  * Yanked from i386/i386/autoconf.c (and tweaked a bit)
        !            78:  */
        !            79: void
        !            80: findbootdev()
        !            81: {
        !            82:        struct device *dv;
        !            83:        int major, unit;
        !            84:
        !            85:        booted_device = NULL;
        !            86:        booted_partition = 0;   /* Assume root is on partition a */
        !            87:
        !            88:        major = B_TYPE(bootdev);
        !            89:        if (major < 0 || major >= nblkdev)
        !            90:                return;
        !            91:
        !            92:        unit = B_UNIT(bootdev);
        !            93:
        !            94:        bootdev &= ~(B_UNITMASK << B_UNITSHIFT);
        !            95:        unit = target_to_unit(-1, unit, 0);
        !            96:        bootdev |= (unit << B_UNITSHIFT);
        !            97:
        !            98:        if (disk_count <= 0)
        !            99:                return;
        !           100:
        !           101:        TAILQ_FOREACH(dv, &alldevs, dv_list) {
        !           102:                if (dv->dv_class == DV_DISK && major == findblkmajor(dv) &&
        !           103:                    unit == dv->dv_unit) {
        !           104:                        booted_device = dv;
        !           105:                        return;
        !           106:                }
        !           107:        }
        !           108: }
        !           109:
        !           110: void
        !           111: cpu_configure()
        !           112: {
        !           113:        startrtclock();
        !           114:
        !           115:        if (config_rootfound("mainbus", "mainbus") == NULL)
        !           116:                panic("No mainbus found!");
        !           117:        spl0();
        !           118:
        !           119:        findbootdev();
        !           120:        cold = 0;
        !           121: }
        !           122:
        !           123: void
        !           124: device_register(struct device *dev, void *aux)
        !           125: {
        !           126: }
        !           127:
        !           128: void
        !           129: diskconf(void)
        !           130: {
        !           131:        setroot(booted_device, booted_partition, RB_USERREQ);
        !           132:        dumpconf();
        !           133: }
        !           134:
        !           135: /*
        !           136:  * Map a SCSI bus, target, lun to a device number.
        !           137:  * This could be tape, disk, CD.  The calling routine, though,
        !           138:  * assumes DISK.  It would be nice to allow CD, too...
        !           139:  */
        !           140: int
        !           141: target_to_unit(bus, target, lun)
        !           142:        u_long bus, target, lun;
        !           143: {
        !           144:        struct scsibus_softc    *scsi;
        !           145:        struct scsi_link        *sc_link;
        !           146:        struct device           *sc_dev;
        !           147:        extern  struct cfdriver         scsibus_cd;
        !           148:
        !           149:        if (target < 0 || target > 7 || lun < 0 || lun > 7) {
        !           150:                printf("scsi target to unit, target (%ld) or lun (%ld)"
        !           151:                        " out of range.\n", target, lun);
        !           152:                return -1;
        !           153:        }
        !           154:
        !           155:        if (bus == -1) {
        !           156:                for (bus = 0 ; bus < scsibus_cd.cd_ndevs ; bus++) {
        !           157:                        if (scsibus_cd.cd_devs[bus]) {
        !           158:                                scsi = (struct scsibus_softc *)
        !           159:                                                scsibus_cd.cd_devs[bus];
        !           160:                                if (scsi->sc_link[target][lun]) {
        !           161:                                        sc_link = scsi->sc_link[target][lun];
        !           162:                                        sc_dev = (struct device *)
        !           163:                                                        sc_link->device_softc;
        !           164:                                        return sc_dev->dv_unit;
        !           165:                                }
        !           166:                        }
        !           167:                }
        !           168:                return -1;
        !           169:        }
        !           170:        if (bus < 0 || bus >= scsibus_cd.cd_ndevs) {
        !           171:                printf("scsi target to unit, bus (%ld) out of range.\n", bus);
        !           172:                return -1;
        !           173:        }
        !           174:        if (scsibus_cd.cd_devs[bus]) {
        !           175:                scsi = (struct scsibus_softc *) scsibus_cd.cd_devs[bus];
        !           176:                if (scsi->sc_link[target][lun]) {
        !           177:                        sc_link = scsi->sc_link[target][lun];
        !           178:                        sc_dev = (struct device *) sc_link->device_softc;
        !           179:                        return sc_dev->dv_unit;
        !           180:                }
        !           181:        }
        !           182:        return -1;
        !           183: }
        !           184:
        !           185: struct nam2blk nam2blk[] = {
        !           186:        { "sd",         4 },
        !           187:        { "cd",         6 },
        !           188:        { "rd",         13 },
        !           189:        { NULL,         -1 }
        !           190: };

CVSweb