Annotation of coherent/b/STREAMS/conf/bin/src/mdev.h, revision 1.1.1.1

1.1       root        1: #ifndef        MDEV_H
                      2: #define        MDEV_H
                      3: 
                      4: #include "devadm.h"
                      5: 
                      6: 
                      7: enum {
                      8:        MD_DISABLED,
                      9:        MD_INSTALLABLE,
                     10:        MD_ENABLED
                     11: };
                     12: 
                     13: 
                     14: /*
                     15:  * Structure of the data gathered by the mdev routines.
                     16:  */
                     17: 
                     18: typedef        unsigned int    maj_t;
                     19: typedef        unsigned int    min_t;
                     20: 
                     21: struct mdevice {
                     22:        mdev_t        * md_next;        /* global list of all entries */
                     23:        mdev_t        * md_chrlink;     /* for sorts */
                     24:        mdev_t        * md_blklink;     /* for sorts */
                     25:        mdev_t        * md_modlink;     /* for sorts */
                     26:        mdev_t        * md_cohlink;     /* for sorts */
                     27: 
                     28:        sdev_t        * md_sdevices;    /* thread of "sdevice" entries */
                     29:        int             md_configure;   /* See MD_... constants */
                     30:        int             md_interrupt;   /* has an enabled interrupt */
                     31: 
                     32:        symbol_t      * md_devname;     /* internal module/device name */
                     33:        symbol_t      * md_functions;   /* present driver entry points */
                     34:        symbol_t      * md_flags;       /* driver characteristics */
                     35:        symbol_t      * md_prefix;      /* driver prefix */
                     36:        maj_t           md_blk_maj [2]; /* block major number low, high */
                     37:        maj_t           md_chr_maj [2]; /* character major number low, high */
                     38:        min_t           md_minor_min;   /* minor number minimum */
                     39:        min_t           md_minor_max;   /* minor number maximum */
                     40: 
                     41:        /*
                     42:         * The following fields are not used in the Coherent system as yet
                     43:         * but are defined by mdevice (4) so we read them.
                     44:         */
                     45: 
                     46:        int             md_dma_chan;    /* DMA channel number */
                     47:        int             md_cpu_id;      /* processor-id */
                     48: };
                     49: 
                     50: 
                     51: /*
                     52:  * Types suitable for use as selection and comparison predicates for the
                     53:  * mdev_sort () function.
                     54:  */
                     55: 
                     56: typedef        int  (* msel_t)         PROTO ((mdev_t * _mdevp));
                     57: typedef int  (*        mcmp_t)         PROTO ((mdev_t * _left, mdev_t * _right));
                     58: typedef        void (* miter_t)        PROTO ((VOID * _extra, mdev_t * _mdevp));
                     59: 
                     60: 
                     61: /*
                     62:  * For Coherent, the first 32 major numbers are reserved for the use of the
                     63:  * old-style Coherent device-driver system.
                     64:  */
                     65: 
                     66: enum {
                     67:        MAJOR_RESERVED          = 32,
                     68:        MAX_DEVNAME             = 8,
                     69:        MAX_PREFIX              = 4
                     70: };
                     71: 
                     72: enum {
                     73:        MDEV_OPEN               = 'o',
                     74:        MDEV_CLOSE              = 'c',
                     75:        MDEV_READ               = 'r',
                     76:        MDEV_WRITE              = 'w',
                     77:        MDEV_IOCTL              = 'i',
                     78:        MDEV_STARTUP            = 's',
                     79:        MDEV_EXIT               = 'x',
                     80:        MDEV_INIT               = 'I',
                     81:        MDEV_HALT               = 'h',
                     82:        MDEV_CHPOLL             = 'p',
                     83: 
                     84:        MDEV_MMAP               = 'M',  /* not defined in SVR4 mdevice (4) */
                     85:        MDEV_SIZE               = 'z'   /* not defined in SVR4 mdevice (4) */
                     86: };
                     87: 
                     88: #define        MDEV_FUNCS              "ocrwisxIhpMz"
                     89: 
                     90: enum {
                     91:        MDEV_INSTALLABLE        = 'i',
                     92:        MDEV_CHAR               = 'c',
                     93:        MDEV_BLOCK              = 'b',
                     94:        MDEV_STREAM             = 'S',
                     95:        MDEV_DDI_DDK            = 'f',
                     96:        MDEV_TTY                = 't',
                     97:        MDEV_ONE_SDEVICE        = 'o',
                     98:        MDEV_REQUIRED           = 'r',
                     99:        MDEV_SAME_MAJORS        = 'u',
                    100:        MDEV_HARDWARE           = 'H',
                    101:        MDEV_NO_INT             = 'G',
                    102:        MDEV_SHARE_DMA          = 'D',
                    103:        MDEV_MULTIPLE_MAJORS    = 'M',
                    104:        MDEV_ALLOW_IOA_OVERLAP  = 'O',
                    105: 
                    106: /*
                    107:  * The following flag specifies that we are dealing with an old-style Coherent
                    108:  * device driver. These drivers ignore any interrupt settings, doing their
                    109:  * work though the mtune/stune system instead, so the 'G' flag also applies.
                    110:  * The 'o' flag is also appropriate.
                    111:  */
                    112: 
                    113:        MDEV_COHERENT           = 'C'
                    114: };
                    115: 
                    116: #define        MDEV_FLAGS              "icbSftoruHGDMOC"
                    117: 
                    118: 
                    119: EXTERN_C_BEGIN
                    120: 
                    121: mdev_t       * find_mdev       PROTO ((symbol_t * _sym));
                    122: void           for_all_mdevices PROTO ((miter_t _iter, VOID * _extra));
                    123: int            mdev_func       PROTO ((mdev_t * _mdevp, char _func));
                    124: int            mdev_flag       PROTO ((mdev_t * _mdevp, char _flag));
                    125: void           read_mdev_file  PROTO ((CONST char * _inname,
                    126:                                        CONST char * _outname,
                    127:                                        VOID * _extra));
                    128: void           read_mdev_string PROTO ((CONST char * _string,
                    129:                                         VOID * _extra));
                    130: int            mdev_sort       PROTO ((mdev_t ** _mlistp, mdev_t ** _mdendp,
                    131:                                        msel_t _selpred, mcmp_t _cmppred,
                    132:                                        size_t _ptroff));
                    133: void           write_mdevice   PROTO ((mdev_t * _mdevp, input_t * _input));
                    134: 
                    135: EXTERN_C_END
                    136: 
                    137: #endif /* ! defined (MDEV_H) */

unix.superglobalmegacorp.com

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