Return to rs_io.s CVS log

Up to [Early Linux] / linux / kernel

Annotation of linux/kernel/rs_io.s, revision 1.1

1.1     ! root        1: /*
        !             2:  *     rs_io.s
        !             3:  *
        !             4:  * This module implements the rs232 io interrupts.
        !             5:  */
        !             6: 
        !             7: .text
        !             8: .globl _rs1_interrupt,_rs2_interrupt
        !             9: 
        !            10: size   = 1024                          /* must be power of two !
        !            11:                                           and must match the value
        !            12:                                           in tty_io.c!!! */
        !            13: 
        !            14: /* these are the offsets into the read/write buffer structures */
        !            15: rs_addr = 0
        !            16: head = 4
        !            17: tail = 8
        !            18: proc_list = 12
        !            19: buf = 16
        !            20: 
        !            21: startup        = 256           /* chars left in write queue when we restart it */
        !            22: 
        !            23: /*
        !            24:  * These are the actual interrupt routines. They look where
        !            25:  * the interrupt is coming from, and take appropriate action.
        !            26:  */
        !            27: .align 2
        !            28: _rs1_interrupt:
        !            29:        pushl $_table_list+8
        !            30:        jmp rs_int
        !            31: .align 2
        !            32: _rs2_interrupt:
        !            33:        pushl $_table_list+16
        !            34: rs_int:
        !            35:        pushl %edx
        !            36:        pushl %ecx
        !            37:        pushl %ebx
        !            38:        pushl %eax
        !            39:        push %es
        !            40:        push %ds                /* as this is an interrupt, we cannot */
        !            41:        pushl $0x10             /* know that bs is ok. Load it */
        !            42:        pop %ds
        !            43:        pushl $0x10
        !            44:        pop %es
        !            45:        movl 24(%esp),%edx
        !            46:        movl (%edx),%edx
        !            47:        movl rs_addr(%edx),%edx
        !            48:        addl $2,%edx            /* interrupt ident. reg */
        !            49: rep_int:
        !            50:        xorl %eax,%eax
        !            51:        inb %dx,%al
        !            52:        testb $1,%al
        !            53:        jne end
        !            54:        cmpb $6,%al             /* this shouldn't happen, but ... */
        !            55:        ja end
        !            56:        movl 24(%esp),%ecx
        !            57:        pushl %edx
        !            58:        subl $2,%edx
        !            59:        call jmp_table(,%eax,2)         /* NOTE! not *4, bit0 is 0 already */
        !            60:        popl %edx
        !            61:        jmp rep_int
        !            62: end:   movb $0x20,%al
        !            63:        outb %al,$0x20          /* EOI */
        !            64:        pop %ds
        !            65:        pop %es
        !            66:        popl %eax
        !            67:        popl %ebx
        !            68:        popl %ecx
        !            69:        popl %edx
        !            70:        addl $4,%esp            # jump over _table_list entry
        !            71:        iret
        !            72: 
        !            73: jmp_table:
        !            74:        .long modem_status,write_char,read_char,line_status
        !            75: 
        !            76: .align 2
        !            77: modem_status:
        !            78:        addl $6,%edx            /* clear intr by reading modem status reg */
        !            79:        inb %dx,%al
        !            80:        ret
        !            81: 
        !            82: .align 2
        !            83: line_status:
        !            84:        addl $5,%edx            /* clear intr by reading line status reg. */
        !            85:        inb %dx,%al
        !            86:        ret
        !            87: 
        !            88: .align 2
        !            89: read_char:
        !            90:        inb %dx,%al
        !            91:        movl %ecx,%edx
        !            92:        subl $_table_list,%edx
        !            93:        shrl $3,%edx
        !            94:        movl (%ecx),%ecx                # read-queue
        !            95:        movl head(%ecx),%ebx
        !            96:        movb %al,buf(%ecx,%ebx)
        !            97:        incl %ebx
        !            98:        andl $size-1,%ebx
        !            99:        cmpl tail(%ecx),%ebx
        !           100:        je 1f
        !           101:        movl %ebx,head(%ecx)
        !           102:        pushl %edx
        !           103:        call _do_tty_interrupt
        !           104:        addl $4,%esp
        !           105: 1:     ret
        !           106: 
        !           107: .align 2
        !           108: write_char:
        !           109:        movl 4(%ecx),%ecx               # write-queue
        !           110:        movl head(%ecx),%ebx
        !           111:        subl tail(%ecx),%ebx
        !           112:        andl $size-1,%ebx               # nr chars in queue
        !           113:        je write_buffer_empty
        !           114:        cmpl $startup,%ebx
        !           115:        ja 1f
        !           116:        movl proc_list(%ecx),%ebx       # wake up sleeping process
        !           117:        testl %ebx,%ebx                 # is there any?
        !           118:        je 1f
        !           119:        movl $0,(%ebx)
        !           120: 1:     movl tail(%ecx),%ebx
        !           121:        movb buf(%ecx,%ebx),%al
        !           122:        outb %al,%dx
        !           123:        incl %ebx
        !           124:        andl $size-1,%ebx
        !           125:        movl %ebx,tail(%ecx)
        !           126:        cmpl head(%ecx),%ebx
        !           127:        je write_buffer_empty
        !           128:        ret
        !           129: .align 2
        !           130: write_buffer_empty:
        !           131:        movl proc_list(%ecx),%ebx       # wake up sleeping process
        !           132:        testl %ebx,%ebx                 # is there any?
        !           133:        je 1f
        !           134:        movl $0,(%ebx)
        !           135: 1:     incl %edx
        !           136:        inb %dx,%al
        !           137:        jmp 1f
        !           138: 1:     jmp 1f
        !           139: 1:     andb $0xd,%al           /* disable transmit interrupt */
        !           140:        outb %al,%dx
        !           141:        ret

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