/*
* Copyright 2006-2010, Ingo Weinhold <ingo_weinhold@gmx.de>.
* All rights reserved. Distributed under the terms of the MIT License.
*
* Copyright 2003, Travis Geiselbrecht. All rights reserved.
* Distributed under the terms of the NewOS License.
*/
#include "asm_defs.h"
#include "asm_offsets.h"
#define MSR_EXCEPTIONS_ENABLED 15
.text
// TODO: FIXME
FUNCTION(reboot):
b .
FUNCTION_END(reboot)
/* void arch_int_enable_interrupts(void) */
FUNCTION(arch_int_enable_interrupts):
mfmsr %r3 // load msr
li %r4, 1
insrwi %r3, %r4, 1, 31 - MSR_EXCEPTIONS_ENABLED
// sets bit 15, EE
mtmsr %r3 // put it back into the msr
isync
blr
FUNCTION_END(arch_int_enable_interrupts)
/* int arch_int_disable_interrupts(void)
* r3
*/
FUNCTION(arch_int_disable_interrupts):
mfmsr %r4 // load msr
mr %r3, %r4 // save old state
rlwinm %r4, %r4, 0, 32 - MSR_EXCEPTIONS_ENABLED, 30 - MSR_EXCEPTIONS_ENABLED
// clears bit 15, EE
mtmsr %r4 // put it back into the msr
isync
blr
FUNCTION_END(arch_int_disable_interrupts)
/* void arch_int_restore_interrupts(int oldState)
* r3
*/
FUNCTION(arch_int_restore_interrupts):
mfmsr %r4
rlwimi %r4, %r3, 0, 31 - MSR_EXCEPTIONS_ENABLED, 31 - MSR_EXCEPTIONS_ENABLED
// clear or set bit 15, EE to the same state as in r3, oldState
mtmsr %r4
isync
blr
FUNCTION_END(arch_int_restore_interrupts)
/* bool arch_int_are_interrupts_enabled(void) */
FUNCTION(arch_int_are_interrupts_enabled):
mfmsr %r3 // load msr
extrwi %r3, %r3, 1, 31 - MSR_EXCEPTIONS_ENABLED
// mask out the EE bit
blr
FUNCTION_END(arch_int_are_interrupts_enabled)
// TODO: FIXME
FUNCTION(dbg_save_registers):
blr
FUNCTION_END(dbg_save_registers)
/* long long get_time_base(void) */
FUNCTION(get_time_base):
1:
mftbu %r3 // get the upper time base register
mftb %r4 // get the lower time base register
mftbu %r5 // get the upper again
cmpw %r5, %r3 // see if it changed while we were reading the lower
bne- 1b // if so, repeat
blr
FUNCTION_END(get_time_base)
/* void getibats(int bats[8])
FUNCTION(getibats):
mfibatu %r0,0
stw %r0,0(%r3)
mfibatl %r0,0
stwu %r0,4(%r3)
mfibatu %r0,1
stwu %r0,4(%r3)
mfibatl %r0,1
stwu %r0,4(%r3)
mfibatu %r0,2
stwu %r0,4(%r3)
mfibatl %r0,2
stwu %r0,4(%r3)
mfibatu %r0,3
stwu %r0,4(%r3)
mfibatl %r0,3
stwu %r0,4(%r3)
blr
FUNCTION_END(getibats)
// void setibats(int bats[8])
FUNCTION(setibats):
lwz %r0,0(%r3)
mtibatu 0,%r0
isync
lwzu %r0,4(%r3)
mtibatl 0,%r0
isync
lwzu %r0,4(%r3)
mtibatu 1,%r0
isync
lwzu %r0,4(%r3)
mtibatl 1,%r0
isync
lwzu %r0,4(%r3)
mtibatu 2,%r0
isync
lwzu %r0,4(%r3)
mtibatl 2,%r0
isync
lwzu %r0,4(%r3)
mtibatu 3,%r0
isync
lwzu %r0,4(%r3)
mtibatl 3,%r0
isync
blr
FUNCTION_END(setibats)
// void getdbats(int bats[8])
FUNCTION(getdbats):
mfdbatu %r0,0
stw %r0,0(%r3)
mfdbatl %r0,0
stwu %r0,4(%r3)
mfdbatu %r0,1
stwu %r0,4(%r3)
mfdbatl %r0,1
stwu %r0,4(%r3)
mfdbatu %r0,2
stwu %r0,4(%r3)
mfdbatl %r0,2
stwu %r0,4(%r3)
mfdbatu %r0,3
stwu %r0,4(%r3)
mfdbatl %r0,3
stwu %r0,4(%r3)
blr
FUNCTION_END(getdbats)
// void setdbats(int bats[8])
FUNCTION(setdbats):
lwz %r0,0(%r3)
mtdbatu 0,%r0
lwzu %r0,4(%r3)
mtdbatl 0,%r0
lwzu %r0,4(%r3)
mtdbatu 1,%r0
lwzu %r0,4(%r3)
mtdbatl 1,%r0
lwzu %r0,4(%r3)
mtdbatu 2,%r0
lwzu %r0,4(%r3)
mtdbatl 2,%r0
lwzu %r0,4(%r3)
mtdbatu 3,%r0
lwzu %r0,4(%r3)
mtdbatl 3,%r0
sync
blr
FUNCTION_END(setdbats)
// unsigned int gethid0()
FUNCTION(gethid0):
mfspr %r3, 1008
blr
FUNCTION_END(gethid0)
// void sethid0(unsigned int val)
FUNCTION(sethid0):
isync
mtspr 1008, %r3
isync
blr
FUNCTION_END(sethid0)
// unsigned int getl2cr()
FUNCTION(getl2cr):
mfspr %r3, 1017
blr
FUNCTION_END(getl2cr)
// void setl2cr(unsigned int val)
FUNCTION(setl2cr):
isync
mtspr 1017, %r3
isync
blr
FUNCTION_END(setl2cr)
// void ppc_context_switch(addr_t *old_sp, addr_t new_sp)
FUNCTION(ppc_context_switch):
// regs to push on the stack: f13-f31, r13-r31, cr, r2, lr
// push the old regs we need to save on the stack
// f31-13
stfdu %f31, -8(%r1)
stfdu %f30, -8(%r1)
stfdu %f29, -8(%r1)
stfdu %f28, -8(%r1)
stfdu %f27, -8(%r1)
stfdu %f26, -8(%r1)
stfdu %f25, -8(%r1)
stfdu %f24, -8(%r1)
stfdu %f23, -8(%r1)
stfdu %f22, -8(%r1)
stfdu %f21, -8(%r1)
stfdu %f20, -8(%r1)
stfdu %f19, -8(%r1)
stfdu %f18, -8(%r1)
stfdu %f17, -8(%r1)
stfdu %f16, -8(%r1)
stfdu %f15, -8(%r1)
stfdu %f14, -8(%r1)
stfdu %f13, -8(%r1)
// r31-13, r2
stwu %r31, -4(%r1)
stwu %r30, -4(%r1)
stwu %r29, -4(%r1)
stwu %r28, -4(%r1)
stwu %r27, -4(%r1)
stwu %r26, -4(%r1)
stwu %r25, -4(%r1)
stwu %r24, -4(%r1)
stwu %r23, -4(%r1)
stwu %r22, -4(%r1)
stwu %r21, -4(%r1)
stwu %r20, -4(%r1)
stwu %r19, -4(%r1)
stwu %r18, -4(%r1)
stwu %r17, -4(%r1)
stwu %r16, -4(%r1)
stwu %r15, -4(%r1)
stwu %r14, -4(%r1)
stwu %r13, -4(%r1)
stwu %r2, -4(%r1)
// CR and LR
mfcr %r0
stwu %r0, -4(%r1)
mflr %r0
stwu %r0, -4(%r1)
// save the old stack pointer
stwu %r1, 0(%r3)
// restore the new stack pointer
mr %r1, %r4
// restore the new regs
// LR and CR
lwz %r0, 0(%r1)
mtlr %r0
lwzu %r0, 4(%r1)
mtcr %r0
// r2, r13-31
lwzu %r2, 4(%r1)
lwzu %r13, 4(%r1)
lwzu %r14, 4(%r1)
lwzu %r15, 4(%r1)
lwzu %r16, 4(%r1)
lwzu %r17, 4(%r1)
lwzu %r18, 4(%r1)
lwzu %r19, 4(%r1)
lwzu %r20, 4(%r1)
lwzu %r21, 4(%r1)
lwzu %r22, 4(%r1)
lwzu %r23, 4(%r1)
lwzu %r24, 4(%r1)
lwzu %r25, 4(%r1)
lwzu %r26, 4(%r1)
lwzu %r27, 4(%r1)
lwzu %r28, 4(%r1)
lwzu %r29, 4(%r1)
lwzu %r30, 4(%r1)
lwzu %r31, 4(%r1)
// f13-31
lfdu %f13, 4(%r1)
lfdu %f14, 8(%r1)
lfdu %f15, 8(%r1)
lfdu %f16, 8(%r1)
lfdu %f17, 8(%r1)
lfdu %f18, 8(%r1)
lfdu %f19, 8(%r1)
lfdu %f20, 8(%r1)
lfdu %f21, 8(%r1)
lfdu %f22, 8(%r1)
lfdu %f23, 8(%r1)
lfdu %f24, 8(%r1)
lfdu %f25, 8(%r1)
lfdu %f26, 8(%r1)
lfdu %f27, 8(%r1)
lfdu %f28, 8(%r1)
lfdu %f29, 8(%r1)
lfdu %f30, 8(%r1)
lfdu %f31, 8(%r1)
addi %r1, %r1, 8
blr
FUNCTION_END(ppc_context_switch)
// ppc_kernel_thread_root(): parameters in r13-r15, the functions to call
// (in that order). The function is used when spawing threads. It usually calls
// an initialization function, the actual thread function, and a function that
// destroys the thread.
FUNCTION(ppc_kernel_thread_root):
mtlr %r13
blrl
mtlr %r14
blrl
mtlr %r15
blrl
// We should never get here. If we do, it's time to enter the kernel
// debugger (without a message at the moment).
li %r3, 0
b kernel_debugger
FUNCTION_END(ppc_kernel_thread_root)
/*! \fn void arch_debug_call_with_fault_handler(cpu_ent* cpu,
jmp_buf jumpBuffer, void (*function)(void*), void* parameter)
Called by debug_call_with_fault_handler() to do the dirty work of setting
the fault handler and calling the function. If the function causes a page
fault, the arch_debug_call_with_fault_handler() calls longjmp() with the
given \a jumpBuffer. Otherwise it returns normally.
debug_call_with_fault_handler() has already saved the CPU's fault_handler
and fault_handler_stack_pointer and will reset them later, so
arch_debug_call_with_fault_handler() doesn't need to care about it.
\param cpu The \c cpu_ent for the current CPU.
\param jumpBuffer Buffer to be used for longjmp().
\param function The function to be called.
\param parameter The parameter to be passed to the function to be called.
*/
FUNCTION(arch_debug_call_with_fault_handler):
// prolog: setup stack frame (16-byte aligned)
mflr %r0
stw %r0, 4(%r1) // store LR
stwu %r1, -16(%r1) // store back chain
stw %r4, 8(%r1) // store jumpBuffer
// set cpu->fault_handler_stack_pointer
stw %r1, CPU_ENT_fault_handler_stack_pointer(%r3)
// set cpu->fault_handler
lis %r11, 1f@ha
ori %r11, %r11, 1f@l
stw %r11, CPU_ENT_fault_handler(%r3)
// call the given function
mr %r3, %r6
mtlr %r5
blrl
// epilog: restore stack frame
lwz %r0, 16 + 4(%r1) // load LR
mtlr %r0
addi %r1, %r1, 16 // restore SP
blr
// fault -- return via longjmp(jumpBuffer, 1)
1:
lwz %r3, 8(%r1) // load jumpBuffer
// call longjmp
li %r4, 1
lis %r0, longjmp@ha
ori %r0, %r0, longjmp@l
mtlr %r0
blr
FUNCTION_END(arch_debug_call_with_fault_handler)
/* status_t arch_cpu_user_memcpy(void *to, const void *from, size_t size, addr_t *faultHandler) */
FUNCTION(_arch_cpu_user_memcpy):
// TODO
blr
FUNCTION_END(_arch_cpu_user_memcpy)
/* status_t arch_cpu_user_memset(void *to, char c, size_t count, addr_t *faultHandler) */
FUNCTION(_arch_cpu_user_memset):
// TODO
blr
FUNCTION_END(_arch_cpu_user_memset)
/* ssize_t arch_cpu_user_strlcpy(void *to, const void *from, size_t size, addr_t *faultHandler) */
FUNCTION(_arch_cpu_user_strlcpy):
// TODO
blr
FUNCTION_END(_arch_cpu_user_strlcpy)
