Return to devs.c CVS log

Up to [local] / sys / arch / landisk / stand / boot

Annotation of sys/arch/landisk/stand/boot/devs.c, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: devs.c,v 1.6 2006/11/16 23:12:56 deraadt Exp $        */
                      2:
                      3: /*
                      4:  * Copyright (c) 2006 Michael Shalayeff
                      5:  * All rights reserved.
                      6:  *
                      7:  * Permission to use, copy, modify, and distribute this software for any
                      8:  * purpose with or without fee is hereby granted, provided that the above
                      9:  * copyright notice and this permission notice appear in all copies.
                     10:  *
                     11:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     12:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     13:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     14:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     15:  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
                     16:  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
                     17:  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     18:  */
                     19:
                     20: #include <sys/param.h>
                     21: #include <libsa.h>
                     22: #include <lib/libsa/loadfile.h>
                     23:
                     24: int sector;
                     25:
                     26: void
                     27: machdep(void)
                     28: {
                     29:        tick_init();
                     30:
                     31:        /* scif_init(9600); */
                     32: }
                     33:
                     34: int
                     35: devopen(struct open_file *f, const char *fname, char **file)
                     36: {
                     37:        if (fname[0] != 'c' || fname[1] != 'f' || fname[2] != ':')
                     38:                return EINVAL;
                     39:
                     40:        *file = (char *)fname + 3;
                     41:        f->f_flags |= F_NODEV;
                     42:        f->f_dev = &devsw[0];
                     43:        return (0);
                     44: }
                     45:
                     46: void
                     47: devboot(dev_t bootdev, char *p)
                     48: {
                     49:        sector = bootdev;       /* passed from pbr */
                     50:        p[0] = 'c';
                     51:        p[1] = 'f';
                     52:        p[2] = '\0';
                     53: }
                     54:
                     55: char *
                     56: ttyname(int fd)
                     57: {
                     58:        return "scif";
                     59: }
                     60:
                     61: dev_t
                     62: ttydev(char *name)
                     63: {
                     64:        return NODEV;
                     65: }
                     66:
                     67: int
                     68: cnspeed(dev_t dev, int sp)
                     69: {
                     70:        scif_init(sp);
                     71:        return sp;
                     72: }
                     73:
                     74: void
                     75: run_loadfile(u_long *marks, int howto)
                     76: {
                     77:        u_long entry;
                     78:
                     79:        entry = marks[MARK_ENTRY];
                     80:        cache_flush();
                     81:        cache_disable();
                     82:
                     83:        (*(void (*)(int,int,int))entry)(howto, marks[MARK_END], 0);
                     84: }
                     85:
                     86: int
                     87: blkdevopen(struct open_file *f, ...)
                     88: {
                     89:        return 0;
                     90: }
                     91:
                     92: int
                     93: blkdevstrategy(void *v, int flag, daddr_t dblk, size_t size, void *buf, size_t *rsize)
                     94: {
                     95:
                     96:        if (flag != F_READ)
                     97:                return EROFS;
                     98:
                     99:        if (size & (DEV_BSIZE - 1))
                    100:                return EINVAL;
                    101:
                    102:        if (rsize)
                    103:                *rsize = size;
                    104:
                    105:        if (size != 0 && readsects(0x40, sector + dblk, buf,
                    106:            size / DEV_BSIZE) != 0)
                    107:                return EIO;
                    108:
                    109:        return 0;
                    110: }
                    111:
                    112: int
                    113: blkdevclose(struct open_file *f)
                    114: {
                    115:        return 0;
                    116: }
                    117:
                    118: int pch_pos = 0;
                    119:
                    120: void
                    121: putchar(int c)
                    122: {
                    123:        switch (c) {
                    124:        case '\177':    /* DEL erases */
                    125:                scif_putc('\b');
                    126:                scif_putc(' ');
                    127:        case '\b':
                    128:                scif_putc('\b');
                    129:                if (pch_pos)
                    130:                        pch_pos--;
                    131:                break;
                    132:        case '\t':
                    133:                do
                    134:                        scif_putc(' ');
                    135:                while (++pch_pos % 8);
                    136:                break;
                    137:        case '\n':
                    138:                scif_putc(c);
                    139:        case '\r':
                    140:                scif_putc('\r');
                    141:                pch_pos=0;
                    142:                break;
                    143:        default:
                    144:                scif_putc(c);
                    145:                pch_pos++;
                    146:                break;
                    147:        }
                    148: }
                    149:
                    150: int
                    151: getchar(void)
                    152: {
                    153:        int c = scif_getc();
                    154:
                    155:        if (c == '\r')
                    156:                c = '\n';
                    157:
                    158:        if ((c < ' ' && c != '\n') || c == '\177')
                    159:                return c;
                    160:
                    161:        putchar(c);
                    162:        return c;
                    163: }