Return to fbutil.c CVS log

Up to [Research Unix] / researchv9 / sys / sundev

Annotation of researchv9/sys/sundev/fbutil.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static  char sccsid[] = "@(#)fbutil.c 1.1 86/02/03 Copyr 1985 Sun Micro";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Copyright (c) 1985 by Sun Microsystems, Inc.
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  * Frame buffer driver utilities.
        !            11:  */
        !            12: 
        !            13: #include "../h/param.h"
        !            14: #include "../h/systm.h"
        !            15: #include "../h/dir.h"
        !            16: #include "../h/user.h"
        !            17: #include "../h/proc.h"
        !            18: #include "../h/buf.h"
        !            19: #include "../h/conf.h"
        !            20: #include "../h/file.h"
        !            21: #include "../machine/pte.h"
        !            22: #include "../machine/mmu.h"
        !            23: #include "../sundev/mbvar.h"
        !            24: 
        !            25: fbopen(dev, flag, numdevs, mb_devs)
        !            26:        dev_t   dev;
        !            27:        int     flag, numdevs;
        !            28:        struct  mb_device **mb_devs;
        !            29: {
        !            30:        register int unit = minor(dev);
        !            31:        struct  mb_device *mb_dev = *(mb_devs+unit);
        !            32: 
        !            33:        if (unit >= numdevs || mb_dev == 0 || mb_dev->md_alive == 0)
        !            34:                u.u_error = ENXIO;
        !            35: }
        !            36: 
        !            37: /*
        !            38:  * Call intclear to turn off interrupts on all alive devices.
        !            39:  * If intclear returns non-zero value then know that found an interrupting
        !            40:  * device.
        !            41:  */
        !            42: int
        !            43: fbintr(numdevs, mb_devs, intclear)
        !            44:        int     numdevs;
        !            45:        struct  mb_device **mb_devs;
        !            46:        int     (*intclear)();
        !            47: {
        !            48:        register int i;
        !            49:        register struct mb_device *md;
        !            50: 
        !            51:        for (i = 0; i < numdevs; i++) {
        !            52:                if ((md = *(mb_devs+i)) == NULL)
        !            53:                        continue;
        !            54:                if (!md->md_alive)
        !            55:                        continue;
        !            56:                if ((*intclear)(md->md_addr))
        !            57:                        return (1);
        !            58:        }
        !            59:        return (0);
        !            60: }
        !            61: 
        !            62: /*ARGSUSED*/
        !            63: int
        !            64: fbmmap(dev, off, prot, numdevs, mb_devs, size)
        !            65:        dev_t   dev;
        !            66:        off_t   off;
        !            67:        int     prot;
        !            68:        int     numdevs;
        !            69:        struct  mb_device **mb_devs;
        !            70:        int     size;
        !            71: {
        !            72:        struct  mb_device *mb_dev = *(mb_devs+minor(dev));
        !            73:        register int page;
        !            74: 
        !            75:        if (off >= size)
        !            76:                return (-1);
        !            77:        page = getkpgmap(mb_dev->md_addr + off) & PG_PFNUM;
        !            78:        return (page);
        !            79: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.