io-acorn.s

arm平台上的uclinux系统全部源代码

/*
 * linux/arch/arm/lib/io.S
 *
 * Copyright (C) 1995, 1996 Russell King
 */
#include <linux/autoconf.h>
#include <asm/assembler.h>
#include <asm/hardware.h>

		.text
		.align

#define OUT(reg)						\
		mov	r8, reg, lsl $16			;\
		orr	r8, r8, r8, lsr $16			;\
		str	r8, [r3, r0, lsl $2]			;\
		mov	r8, reg, lsr $16			;\
		orr	r8, r8, r8, lsl $16			;\
		str	r8, [r3, r0, lsl $2]

#define IN(reg)							\
		ldr	reg, [r0]				;\
		and	reg, reg, ip				;\
		ldr	lr, [r0]				;\
		orr	reg, reg, lr, lsl $16

#if (IO_BASE == (PCIO_BASE & 0xff000000))
#define ADDR(off,reg)						\
		tst	off, $0x80000000			;\
		mov	reg, $IO_BASE				;\
		orreq	reg, reg, $(PCIO_BASE & 0x00ff0000)
#else
#define ADDR(off,reg)						\
		tst	off, $0x80000000			;\
		movne	reg, $IO_BASE				;\
		moveq	reg, $(PCIO_BASE & 0xff000000)		;\
		orreq	reg, reg, $(PCIO_BASE & 0x00ff0000)
#endif

@ purpose: read a byte from a hardware register.
@ Proto  : unsigned char inb(int address);

		.global	___inb
		.global	___inb_p
		.global	___inbc
		.global	___inbc_p
___inb:
___inb_p:
___inbc:
___inbc_p:
		ADDR(r0,r2)
		ldrb	r0, [r2, r0, lsl#2]
		RETINSTR(mov,pc,lr)

@ purpose: read a short word from a hardware register.
@ Proto  : unsigned short inw(int address);

		.global	___inw
___inw:		ADDR(r0,r2)
		ldr	r0, [r2, r0, lsl#2]
		bic	r0, r0, #0xff000000
		bic	r0, r0, #0x00ff0000
		RETINSTR(mov,pc,lr)

@ Purpose: write a byte to a hardware register.
@ Proto  : outb(unsigned char c,int address);

		.global	___outb
		.global	___outb_p
		.global	___outbc
		.global	___outbc_p
___outb:
___outb_p:
___outbc:
___outbc_p:
		ADDR(r1,r2)
		strb	r0,[r2,r1,LSL#2]
		RETINSTR(mov,pc,lr)

@ Purpose: write a short to a hardware register.
@ Proto  : outw(unsigned short c,int address);

		.global	___outw
___outw:	ADDR(r1,r2)
		orr	r0, r0, r0, lsl#16
		str	r0, [r2, r1, lsl#2]
		RETINSTR(mov,pc,lr)

@ Purpose: read a block of data from a hardware register to memory.
@ Proto  : insw(int from_port, void *to, int len_in_words);
@ Proto  : inswb(int from_port, void *to, int len_in_bytes);
@ Notes  : increment to

		.global	_insw
		.global	_inswb
_insw:		mov	r2, r2, lsl#1
_inswb:		mov	ip, sp
		stmfd	sp!, {r4 - r10 ,fp ,ip ,lr ,pc}
		sub	fp, ip, #4
		ADDR(r0,r3)
		add	r0, r3, r0, lsl #2
		tst	r1, #3
		beq	Linswok
		tst	r1, #1
		bne	Linsw_notaligned
		cmp	r2, #1
		ldrge	r4, [r0]
		strgeb	r4, [r1], #1
		movgt	r4, r4, LSR#8
		strgtb	r4, [r1], #1
		ldmleea	fp, {r4 - r10, fp, sp, pc}^
		sub	r2, r2, #2
Linswok:	mov	ip, #0xFF
		orr	ip, ip, ip, lsl #8
Linswlp:	subs	r2, r2, #64
		bmi	Linsw_toosmall
		IN(r3)
		IN(r4)
		IN(r5)
		IN(r6)
		IN(r7)
		IN(r8)
		IN(r9)
		IN(r10)
		stmia	r1!, {r3 - r10}
		IN(r3)
		IN(r4)
		IN(r5)
		IN(r6)
		IN(r7)
		IN(r8)
		IN(r9)
		IN(r10)
		stmia	r1!, {r3 - r10}
		bne	Linswlp
		LOADREGS(ea, fp, {r4 - r10, fp, sp, pc})
Linsw_toosmall:
		adds	r2, r2, #32
		bmi	Linsw_toosmall2
Linsw2lp:	IN(r3)
		IN(r4)
		IN(r5)
		IN(r6)
		IN(r7)
		IN(r8)
		IN(r9)
		IN(r10)
		stmia	r1!, {r3 - r10}
		LOADREGS(eqea, fp, {r4 - r10, fp, sp, pc})
		b	Linsw_notaligned
Linsw_toosmall2:
		add	r2, r2, #32
Linsw_notaligned:
		cmp	r2, #1
		LOADREGS(ltea, fp, {r4 - r10, fp, sp, pc})
		ldr	r4, [r0]
		strb	r4, [r1], #1
		movgt	r4, r4, LSR#8
		strgtb	r4, [r1], #1
		subs	r2, r2, #2
		bgt	Linsw_notaligned
		LOADREGS(ea, fp, {r4 - r10, fp, sp, pc})

@ Purpose: write a block of data from memory to a hardware register.
@ Proto  : outsw(int to_reg, void *from, int len_in_words);
@ Proto  : outswb(int to_reg, void *from, int len_in_bytes);
@ Notes  : increments from

		.global	_outsw
		.global	_outswb
_outsw:		mov	r2, r2, LSL#1
_outswb:	mov	ip, sp
		stmfd	sp!, {r4 - r8, fp, ip, lr, pc}
		sub	fp, ip, #4
		ADDR(r0,r3)
		tst	r1, #2
		beq	Loutsw32lp
		ldr	r4, [r1], #2
		mov	r4, r4, lsl #16
		orr	r4, r4, r4, lsr #16
		str	r4, [r3, r0, lsl #2]
		sub	r2, r2, #2
		teq	r2, #0
		LOADREGS(eqea, fp, {r4 - r8, fp, sp, pc})
Loutsw32lp:	subs	r2,r2,#32
		blt	Loutsw_toosmall
		ldmia	r1!,{r4,r5,r6,r7}
		OUT(r4)
		OUT(r5)
		OUT(r6)
		OUT(r7)
		ldmia	r1!,{r4,r5,r6,r7}
		OUT(r4)
		OUT(r5)
		OUT(r6)
		OUT(r7)
		LOADREGS(eqea, fp, {r4 - r8, fp, sp, pc})
		b	Loutsw32lp
Loutsw_toosmall:
		adds	r2,r2,#32
		LOADREGS(eqea, fp, {r4 - r8, fp, sp, pc})
Llpx:		ldr	r4,[r1],#2
		mov	r4,r4,LSL#16
		orr	r4,r4,r4,LSR#16
		str	r4,[r3,r0,LSL#2]
		subs	r2,r2,#2
		bgt	Llpx
		LOADREGS(ea, fp, {r4 - r8, fp, sp, pc})

@ Purpose: write a memc register
@ Proto  : void memc_write(int register, int value);
@ Returns: nothing

#ifndef CONFIG_ARCH_RPC
		.globl	_memc_write
_memc_write:	cmp	r0, #7
		RETINSTR(movgt,pc,lr)
		mov	r0, r0, lsl #17
		mov	r1, r1, lsl #15
		mov	r1, r1, lsr #17
		orr	r0, r0, r1, lsl #2
		add	r0, r0, #0x03600000
		strb	r0, [r0]
		RETINSTR(mov,pc,lr)
#define CPSR2SPSR(rt)
#else
#define CPSR2SPSR(rt) \
		mrs	rt, cpsr; \
		msr	spsr, rt
#endif

@ Purpose: call an expansion card loader to read bytes.
@ Proto  : char read_loader(int offset, char *card_base, char *loader);
@ Returns: byte read

		.global	_ecard_loader_read
_ecard_loader_read:
		stmfd	sp!, {r4 - r12, lr}
		mov	r11, r1
		mov	r1, r0
		CPSR2SPSR(r0)
		mov	lr, pc
		mov	pc, r2
		LOADREGS(fd, sp!, {r4 - r12, pc})

@ Purpose: call an expansion card loader to reset the card
@ Proto  : void read_loader(int card_base, char *loader);
@ Returns: byte read

		.global	_ecard_loader_reset
_ecard_loader_reset:
		stmfd	sp!, {r4 - r12, lr}
		mov	r11, r0
		CPSR2SPSR(r0)
		mov	lr, pc
		add	pc, r1, #8
		LOADREGS(fd, sp!, {r4 - r12, pc})