Annotation of coherent/f/etc/conf/dummy/src/dummy.c, revision 1.1.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: }

unix.superglobalmegacorp.com

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