Return to AHAInline.h CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / DriverKit / Adaptec1542B / Adaptec1542B_reloc.tproj

Annotation of Examples/DriverKit/Adaptec1542B/Adaptec1542B_reloc.tproj/AHAInline.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1992 NeXT Computer, Inc.
        !             3:  *
        !             4:  * Adaptec AHA-1542 SCSI controller inline functions.
        !             5:  *
        !             6:  * HISTORY
        !             7:  *
        !             8:  * 12 July 1992 David E. Bohman at NeXT
        !             9:  *     Created.
        !            10:  */
        !            11: 
        !            12: #import <driverkit/i386/ioPorts.h>
        !            13: 
        !            14: /*
        !            15:  * Primitives to access the
        !            16:  * board registers.
        !            17:  */
        !            18: 
        !            19: static inline
        !            20: void
        !            21: aha_put_ctrl(
        !            22:     unsigned short     base,
        !            23:     aha_ctrl_reg_t     reg
        !            24: )
        !            25: {
        !            26:     union {
        !            27:        aha_ctrl_reg_t          reg;
        !            28:        unsigned char           data;
        !            29:     } tconv;
        !            30:     
        !            31:     tconv.reg = reg;
        !            32: 
        !            33:     outb(base + AHA_CTRL_REG_OFF, tconv.data);
        !            34: }
        !            35: 
        !            36: static inline
        !            37: aha_stat_reg_t
        !            38: aha_get_stat(
        !            39:     unsigned short     base
        !            40: )
        !            41: {
        !            42:     union {
        !            43:        aha_stat_reg_t          reg;
        !            44:        unsigned char           data;
        !            45:     } tconv;
        !            46: 
        !            47:     tconv.data = inb(base + AHA_STAT_REG_OFF);
        !            48: 
        !            49:     return (tconv.reg);
        !            50: }
        !            51: 
        !            52: static inline
        !            53: aha_intr_reg_t
        !            54: aha_get_intr(
        !            55:     unsigned short     base
        !            56: )
        !            57: {
        !            58:     union {
        !            59:        aha_intr_reg_t          reg;
        !            60:        unsigned char           data;
        !            61:     } tconv;
        !            62: 
        !            63:     tconv.data = inb(base + AHA_INTR_REG_OFF);
        !            64: 
        !            65:     return (tconv.reg);
        !            66: }
        !            67: 
        !            68: static inline
        !            69: void
        !            70: aha_put_cmd(
        !            71:     unsigned short     base,
        !            72:     aha_cmd_reg_t      reg
        !            73: )
        !            74: {
        !            75:     outb(base + AHA_CMD_REG_OFF, reg);
        !            76: }
        !            77: 
        !            78: static inline
        !            79: aha_cmd_reg_t
        !            80: aha_get_cmd(
        !            81:     unsigned short     base
        !            82: )
        !            83: {
        !            84:     return (inb(base + AHA_CMD_REG_OFF));
        !            85: }
        !            86: 
        !            87: /*
        !            88:  * Functions built on top
        !            89:  * of the primatives above.
        !            90:  */
        !            91: 
        !            92: static inline
        !            93: void
        !            94: aha_clr_intr(
        !            95:     unsigned short     base
        !            96: )
        !            97: {
        !            98:     aha_ctrl_reg_t     ctrl = { 0 };
        !            99: 
        !           100:     ctrl.intr_clr = 1;
        !           101: 
        !           102:     aha_put_ctrl(base, ctrl);
        !           103: }
        !           104: 
        !           105: 
        !           106: static inline
        !           107: boolean_t
        !           108: aha_await_datain(
        !           109:     IOEISAPortAddress  base,
        !           110:     unsigned int       how_long
        !           111: )
        !           112: {
        !           113:     aha_stat_reg_t     stat;
        !           114:  
        !           115:     do {
        !           116:        stat = aha_get_stat(base);
        !           117:     } while (!stat.datain_full && how_long--);
        !           118:     return how_long;
        !           119: }
        !           120: 
        !           121: 
        !           122: static inline
        !           123: boolean_t
        !           124: aha_get_bytes(
        !           125:     IOEISAPortAddress  base,
        !           126:     unsigned char      *addr,
        !           127:     unsigned int       length
        !           128: )
        !           129: {
        !           130:     while (length--) {
        !           131:        if (!aha_await_datain(base, 1000))
        !           132:                return FALSE;
        !           133:        *addr++ = inb(base);
        !           134:     }
        !           135:     return TRUE;
        !           136: }
        !           137: 
        !           138: 
        !           139: /*
        !           140:  *  24-bit accessor functions (with byte swapping)
        !           141:  */
        !           142: static inline void
        !           143: aha_put_24(unsigned int source, volatile unsigned char *dest)
        !           144: {
        !           145:        dest[2] = source & 0xff;
        !           146:        dest[1] = (source >> 8) & 0xff;
        !           147:        dest[0] = (source >> 16) & 0xff;
        !           148: }
        !           149: 
        !           150: 
        !           151: static inline unsigned int
        !           152: aha_get_24(volatile unsigned char *source)
        !           153: {
        !           154:        return (source[0] << 16) | (source[1] << 8) | source[2];
        !           155: }
        !           156: 
        !           157: 

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