xref: /qemu/tests/tcg/alpha/system/boot.S (revision 8c1ecb590497b0349c550607db923972b37f6963)

/*
 * Minimal Alpha system boot code.
 *
 * Copyright Linaro Ltd 2019
 */

	.set	noat
	.set	nomacro
	.arch	ev6
	.text

.macro load_pci_io reg
	/* For typhoon, this is
	 *   0xfffffc0000000000  -- kseg identity map
	 * +      0x10000000000  -- typhoon pio base
	 * +        0x1fc000000  -- typhoon pchip0 pci base
	 * = 0xfffffd01fc000000
	 */
	ldah	\reg, -3		/* ff..fd0000 */
	lda	\reg, 0x1fc(\reg)	/* ff..fd01fc */
	sll	\reg, 24, \reg
.endm

#define com1Rbr 0x3f8
#define com1Thr 0x3f8
#define com1Ier 0x3f9
#define com1Iir 0x3fa
#define com1Lcr 0x3fb
#define com1Mcr 0x3fc
#define com1Lsr 0x3fd
#define com1Msr 0x3fe
#define com1Scr 0x3ff
#define com1Dll 0x3f8
#define com1Dlm 0x3f9

#define PAL_halt    0
#define PAL_wrent  52
#define PAL_wrkgp  55

	.text
	.p2align 4
	.globl	_start
	.ent	_start
_start:
	br	$gp, .+4
	ldah	$gp, 0($gp)		!gpdisp!1
	lda	$gp, 0($gp)		!gpdisp!1

	ldah	$sp, $stack_end($gp)	!gprelhigh
	lda	$sp, $stack_end($sp)	!gprellow

	/* Install kernel gp for exception handlers.  */
	mov	$gp, $16
	call_pal PAL_wrkgp

	/* Install exception handlers.  */
	ldah	$16, entInt($gp)	!gprelhigh
	lda	$16, entInt($16)	!gprellow
	lda	$17, 0
	call_pal PAL_wrent

	ldah	$16, entArith($gp)	!gprelhigh
	lda	$16, entArith($16)	!gprellow
	lda	$17, 1
	call_pal PAL_wrent

	ldah	$16, entMM($gp)		!gprelhigh
	lda	$16, entMM($16)		!gprellow
	lda	$17, 2
	call_pal PAL_wrent

	ldah	$16, entIF($gp)		!gprelhigh
	lda	$16, entIF($16)		!gprellow
	lda	$17, 3
	call_pal PAL_wrent

	ldah	$16, entUna($gp)	!gprelhigh
	lda	$16, entUna($16)	!gprellow
	lda	$17, 4
	call_pal PAL_wrent

	ldah	$16, entSys($gp)	!gprelhigh
	lda	$16, entSys($16)	!gprellow
	lda	$17, 5
	call_pal PAL_wrent

	/*
	 * Initialize COM1.
	 */
	load_pci_io $1
	lda	$2, 0x87		/* outb(0x87, com1Lcr); */
	stb	$2, com1Lcr($1)
	stb	$31, com1Dlm($1)	/* outb(0, com1Dlm); */
	lda	$2, 3			/* baudconst 3 => 56000 */
	stb	$2, com1Dll($1)		/* outb(baudconst, com1Dll); */
	lda	$2, 0x07
	stb	$2, com1Lcr($1)		/* outb(0x07, com1Lcr) */
	lda	$2, 0x0f
	stb	$2, com1Mcr($1)		/* outb(0x0f, com1Mcr) */

	bsr	$26, main		!samegp

	/* fall through to _exit */
	.end	_start

	.globl	_exit
	.ent	_exit
_exit:
	.frame	$sp, 0, $26, 0
	.prologue 0

	/* We cannot return an error code.  */
	call_pal PAL_halt
	.end	_exit

/*
 * We have received an exception that we don't handle.  Log and exit.
 */
	.ent	log_exit
log_exit:
entInt:
entArith:
entMM:
entIF:
entUna:
entSys:
	ldah	$16, $errormsg($gp)	!gprelhigh
	lda	$16, $errormsg($16)	!gprellow
	bsr	$26, __sys_outs		!samegp
	bsr	$26, _exit		!samegp
	.end	log_exit

	.section .rodata
$errormsg:
	.string "Terminated by exception.\n"
	.previous

	/*
	 * Helper Functions
	 */

	/* Output a single character to serial port */
	.global __sys_outc
	.ent	__sys_outc
__sys_outc:
	.frame	$sp, 0, $26, 0
	.prologue 0

	load_pci_io $1

	/*
	 * while ((inb(com1Lsr) & 0x20) == 0)
	 *       continue;
	 */
1:	ldbu	$0, com1Lsr($1)
	and	$0, 0x20, $0
	beq	$0, 1b

	/* outb(c, com1Thr); */
	stb	$16, com1Thr($1)
	ret
	.end	__sys_outc

	/* Output a nul-terminated string to serial port */
	.global	__sys_outs
	.ent	__sys_outs
__sys_outs:
	.frame	$sp, 0, $26, 0
	.prologue 0

	load_pci_io $1

	ldbu	$2, 0($16)
	beq	$2, 9f

	/*
	 * while ((inb(com1Lsr) & 0x20) == 0)
	 *       continue;
	 */
1:	ldbu	$0, com1Lsr($1)
	and	$0, 0x20, $0
	beq	$0, 1b

	/* outb(c, com1Thr); */
	stb	$2, com1Thr($1)

	addq	$16, 1, $16
	ldbu	$2, 0($16)
	bne	$2, 1b

9:	ret
	.end	__sys_outs

/*
 * Division routines that are normally in libc.
 *
 * These do not follow the C calling convention.  Arguments are in $24+$25,
 * the result is in $27.  Register $28 may be clobbered; everything else
 * must be saved.
 *
 * We store the remainder in $28, so that we can share code.
 *
 * We do not signal divide by zero.
 */

/*
 * Unsigned 64-bit division.
 */

	.globl	__divqu
	.ent	__divqu
__divqu:
	.frame	$sp, 48, $23
	subq	$sp, 48, $sp
	stq	$0, 0($sp)
	stq	$1, 8($sp)
	stq	$2, 16($sp)
	stq	$3, 24($sp)
	stq	$4, 32($sp)
	.prologue 0

#define mask     $0
#define divisor  $1
#define compare  $2
#define tmp1     $3
#define tmp2     $4
#define quotient $27
#define modulus  $28

	mov	$24, modulus
	mov	$25, divisor
	mov	$31, quotient
	mov	1, mask
	beq	$25, 9f

	/* Shift left until divisor >= modulus.  */
1:	cmpult	divisor, modulus, compare
	blt	divisor, 2f
	addq	divisor, divisor, divisor
	addq	mask, mask, mask
	bne	compare, 1b

2:	addq	quotient, mask, tmp2
	srl	mask, 1, mask
	cmpule	divisor, modulus, compare
	subq	modulus, divisor, tmp1
	cmovne	compare, tmp2, quotient
	srl	divisor, 1, divisor
	cmovne	compare, tmp1, modulus
	bne	mask, 2b

9:	ldq	$0, 0($sp)
	ldq	$1, 8($sp)
	ldq	$2, 16($sp)
	ldq	$3, 24($sp)
	ldq	$4, 32($sp)
	addq	$sp, 48, $sp
	ret	$31, ($23), 1

#undef mask
#undef divisor
#undef compare
#undef tmp1
#undef tmp2
#undef quotient
#undef modulus

	.end	__divqu

/*
 * Unsigned 64-bit remainder.
 * Note that __divqu above leaves the result in $28.
 */

	.globl	__remqu
	.ent	__remqu
__remqu:
	.frame	$sp, 16, $23
	subq	$sp, 16, $sp
	stq	$23, 0($sp)
	.prologue 0

	bsr	$23, __divqu

	ldq	$23, 0($sp)
	mov	$28, $27
	addq	$sp, 16, $sp
	ret	$31, ($23), 1
	.end	__remqu

/*
 * Signed 64-bit division.
 */

	.globl	__divqs
	.ent	__divqs
__divqs:
	.prologue 0

	/* Common case: both arguments are positive.  */
	bis	$24, $25, $28
	bge	$28, __divqu

	/* At least one argument is negative.  */
	subq	$sp, 32, $sp
	stq	$23, 0($sp)
	stq	$24, 8($sp)
	stq	$25, 16($sp)

	/* Compute absolute values.  */
	subq	$31, $24, $28
	cmovlt	$24, $28, $24
	subq	$31, $25, $28
	cmovlt	$25, $28, $25

	bsr	$23, __divqu

	ldq	$24, 8($sp)
	ldq	$25, 16($sp)

	/* -a / b = a / -b = -(a / b) */
	subq	$31, $27, $23
	xor	$24, $25, $28
	cmovlt	$28, $23, $27

	ldq	$23, 0($sp)
	addq	$sp, 32, $sp
	ret	$31, ($23), 1
	.end	__divqs

/*
 * Signed 64-bit remainder.
 */

	.globl	__remqs
	.ent	__remqs
__remqs:
	.prologue 0

	/* Common case: both arguments are positive.  */
	bis	$24, $25, $28
	bge	$28, __remqu

	/* At least one argument is negative.  */
	subq	$sp, 32, $sp
	stq	$23, 0($sp)
	stq	$24, 8($sp)
	stq	$25, 16($sp)

	/* Compute absolute values.  */
	subq	$31, $24, $28
	cmovlt	$24, $28, $24
	subq	$31, $25, $28
	cmovlt	$25, $28, $25

	bsr	$23, __divqu

	ldq	$23, 0($sp)
	ldq	$24, 8($sp)
	ldq	$25, 16($sp)

	/* -a % b = -(a % b); a % -b = a % b.  */
	subq	$31, $28, $27
	cmovge	$24, $28, $27

	addq	$sp, 32, $sp
	ret	$31, ($23), 1
	.end	__remqs

/*
 * Unsigned 32-bit division.
 */

	.globl	__divlu
	.ent	__divlu
__divlu:
	.frame	$sp, 32, $23
	subq	$sp, 32, $sp
	stq	$23, 0($sp)
	stq	$24, 8($sp)
	stq	$25, 16($sp)
	.prologue 0

	/* Zero extend and use the 64-bit routine.  */
	zap	$24, 0xf0, $24
	zap	$25, 0xf0, $25
	bsr	$23, __divqu

	addl	$27, 0, $27
	ldq	$23, 0($sp)
	ldq	$24, 8($sp)
	ldq	$25, 16($sp)
	addq	$sp, 32, $sp
	ret	$31, ($23), 1
	.end	__divlu

/*
 * Unsigned 32-bit remainder.
 */

	.globl	__remlu
	.ent	__remlu
__remlu:
	.frame	$sp, 32, $23
	subq	$sp, 32, $sp
	stq	$23, 0($sp)
	stq	$24, 8($sp)
	stq	$25, 16($sp)
	.prologue 0

	/* Zero extend and use the 64-bit routine.  */
	zap	$24, 0xf0, $24
	zap	$25, 0xf0, $25
	bsr	$23, __divqu

	/* Recall that the remainder is returned in $28.  */
	addl	$28, 0, $27
	ldq	$23, 0($sp)
	ldq	$24, 8($sp)
	ldq	$25, 16($sp)
	addq	$sp, 32, $sp
	ret	$31, ($23), 1
	.end	__remlu

/*
 * Signed 32-bit division.
 */

	.globl	__divls
	.ent	__divls
__divls:
	.frame	$sp, 32, $23
	subq	$sp, 32, $sp
	stq	$23, 0($sp)
	stq	$24, 8($sp)
	stq	$25, 16($sp)
	.prologue 0

	/* Sign extend.  */
	addl	$24, 0, $24
	addl	$25, 0, $25

	/* Compute absolute values.  */
	subq	$31, $24, $28
	cmovlt	$24, $28, $24
	subq	$31, $25, $28
	cmovlt	$25, $28, $25

	bsr	$23, __divqu

	ldq	$24, 8($sp)
	ldq	$25, 16($sp)

	/* Negate the unsigned result, if necessary.  */
	xor	$24, $25, $28
	subl	$31, $27, $23
	addl	$27, 0, $27
	addl	$28, 0, $28
	cmovlt	$28, $23, $27

	ldq	$23, 0($sp)
	addq	$sp, 32, $sp
	ret	$31, ($23), 1
	.end	__divls

/*
 * Signed 32-bit remainder.
 */

	.globl	__remls
	.ent	__remls
__remls:
	.frame	$sp, 32, $23
	subq	$sp, 32, $sp
	stq	$23, 0($sp)
	stq	$24, 8($sp)
	stq	$25, 16($sp)
	.prologue 0

	/* Sign extend.  */
	addl	$24, 0, $24
	addl	$25, 0, $25

	/* Compute absolute values.  */
	subq	$31, $24, $28
	cmovlt	$24, $28, $24
	subq	$31, $25, $28
	cmovlt	$25, $28, $25

	bsr	$23, __divqu

	ldq	$23, 0($sp)
	ldq	$24, 8($sp)
	ldq	$25, 16($sp)

	/* Negate the unsigned result, if necessary.  */
	subl	$31, $28, $27
	addl	$28, 0, $28
	cmovge	$24, $28, $27

	addq	$sp, 32, $sp
	ret	$31, ($23), 1
	.end	__remls

	.data
	.p2align 4
stack:
	.skip	65536
$stack_end:
	.type	stack,@object
	.size	stack, . - stack