Return to dummy.c CVS log

Up to [MW Coherent from dump] / coherent / f / etc / conf / dummy / src

Annotation of coherent/f/etc/conf/dummy/src/dummy.c, revision 1.1

1.1     ! root        1: int dummyInt = 0x98547632;
        !             2: short dummyShort = 0x9876;
        !             3: char dummyChar = 'Z';
        !             4: 
        !             5: /*
        !             6:  * KER/conf/dummy.c
        !             7:  *
        !             8:  * dummy device driver
        !             9:  *
        !            10:  * Revised: Fri Jul 23 12:42:16 1993 CDT
        !            11:  */
        !            12: 
        !            13: /*
        !            14:  * -----------------------------------------------------------------
        !            15:  * Includes.
        !            16:  */
        !            17: #include <sys/coherent.h>
        !            18: #include <sys/cmn_err.h>
        !            19: #include <sys/con.h>
        !            20: #include <sys/errno.h>
        !            21: 
        !            22: /*
        !            23:  * -----------------------------------------------------------------
        !            24:  * Definitions.
        !            25:  *     Constants.
        !            26:  *     Macros with argument lists.
        !            27:  *     Typedefs.
        !            28:  *     Enums.
        !            29:  */
        !            30: 
        !            31: /*
        !            32:  * -----------------------------------------------------------------
        !            33:  * Functions.
        !            34:  *     Import Functions.
        !            35:  *     Export Functions.
        !            36:  *     Local Functions.
        !            37:  */
        !            38: int nulldev();
        !            39: 
        !            40: /*
        !            41:  * Configuration functions (local functions).
        !            42:  */
        !            43: static int dummyclose();
        !            44: static int dummyioctl();
        !            45: static int dummyload();
        !            46: static int dummyopen();
        !            47: static int dummyread();
        !            48: static int dummyunload();
        !            49: static int dummywrite();
        !            50: 
        !            51: /*
        !            52:  * Support functions (local functions).
        !            53:  */
        !            54: 
        !            55: /*
        !            56:  * -----------------------------------------------------------------
        !            57:  * Global Data.
        !            58:  *     Import Variables.
        !            59:  *     Export Variables.
        !            60:  *     Local Variables.
        !            61:  */
        !            62: 
        !            63: /*
        !            64:  * Configuration table (export data).
        !            65:  */
        !            66: CON dummycon ={
        !            67:        DFCHR,                          /* Flags */
        !            68:        0,                              /* Major index */
        !            69:        dummyopen,                      /* Open */
        !            70:        dummyclose,                     /* Close */
        !            71:        nulldev,                        /* Block */
        !            72:        dummyread,                      /* Read */
        !            73:        dummywrite,                     /* Write */
        !            74:        dummyioctl,                     /* Ioctl */
        !            75:        nulldev,                        /* Powerfail */
        !            76:        nulldev,                        /* Timeout */
        !            77:        dummyload,                      /* Load */
        !            78:        dummyunload,                    /* Unload */
        !            79:        nulldev                         /* Poll */
        !            80: };
        !            81: 
        !            82: /*
        !            83:  * -----------------------------------------------------------------
        !            84:  * Code.
        !            85:  */
        !            86: 
        !            87: /*
        !            88:  * dummyload()
        !            89:  */
        !            90: static int
        !            91: dummyload()
        !            92: {
        !            93:        cmn_err(CE_NOTE, "Dummy: load");
        !            94: }
        !            95: 
        !            96: /*
        !            97:  * dummyunload()
        !            98:  */
        !            99: static int
        !           100: dummyunload()
        !           101: {
        !           102:        cmn_err(CE_NOTE, "Dummy: unload");
        !           103: }
        !           104: 
        !           105: /*
        !           106:  * dummyopen()
        !           107:  */
        !           108: static int
        !           109: dummyopen(dev, mode)
        !           110: dev_t dev;
        !           111: int mode;
        !           112: {
        !           113:        cmn_err(CE_NOTE, "Dummy: open");
        !           114: }
        !           115: 
        !           116: /*
        !           117:  * dummyclose()
        !           118:  */
        !           119: static int
        !           120: dummyclose(dev, mode)
        !           121: dev_t dev;
        !           122: int mode;
        !           123: {
        !           124:        cmn_err(CE_NOTE, "Dummy: close");
        !           125: }
        !           126: 
        !           127: /*
        !           128:  * dummyread()
        !           129:  */
        !           130: static int
        !           131: dummyread(dev, iop)
        !           132: dev_t dev;
        !           133: register IO * iop;
        !           134: {
        !           135:        cmn_err(CE_NOTE, "Dummy: read");
        !           136: }
        !           137: 
        !           138: /*
        !           139:  * dummywrite()
        !           140:  */
        !           141: static int
        !           142: dummywrite(dev, iop)
        !           143: dev_t dev;
        !           144: register IO * iop;
        !           145: {
        !           146:        cmn_err(CE_NOTE, "Dummy: write");
        !           147: }
        !           148: 
        !           149: /*
        !           150:  * dummyioctl()
        !           151:  */
        !           152: static int
        !           153: dummyioctl(dev, com, vec)
        !           154: dev_t  dev;
        !           155: int    com;
        !           156: struct sgttyb *vec;
        !           157: {
        !           158:        cmn_err(CE_NOTE, "Dummy: ioctl");
        !           159: }

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