| /* |
| * 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 |
