1/*
2 * Copyright 2003-2011, Haiku, Inc. All rights reserved.
3 * Distributed under the terms of the MIT License.
4 *
5 * Authors:
6 * 		Axel D��rfler <axeld@pinc-software.de>
7 * 		Ingo Weinhold <bonefish@cs.tu-berlin.de>
8 *
9 * Copyright 2001, Travis Geiselbrecht. All rights reserved.
10 * Distributed under the terms of the NewOS License.
11 */
12
13
14#include <arch/cpu.h>
15#include <arch/thread.h>
16#include <boot/stage2.h>
17#include <kernel.h>
18#include <thread.h>
19#include <vm/vm_types.h>
20#include <vm/VMAddressSpace.h>
21//#include <arch/vm_translation_map.h>
22
23#include <string.h>
24
25// Valid initial arch_thread state. We just memcpy() it when initializing
26// a new thread structure.
27static struct arch_thread sInitialState;
28
29// Helper function for thread creation, defined in arch_asm.S.
30extern "C" void ppc_kernel_thread_root();
31
32
33void
34ppc_push_iframe(struct iframe_stack *stack, struct iframe *frame)
35{
36	ASSERT(stack->index < IFRAME_TRACE_DEPTH);
37	stack->frames[stack->index++] = frame;
38}
39
40
41void
42ppc_pop_iframe(struct iframe_stack *stack)
43{
44	ASSERT(stack->index > 0);
45	stack->index--;
46}
47
48
49/**	Returns the current iframe structure of the running thread.
50 *	This function must only be called in a context where it's actually
51 *	sure that such iframe exists; ie. from syscalls, but usually not
52 *	from standard kernel threads.
53 */
54static struct iframe *
55ppc_get_current_iframe(void)
56{
57	Thread *thread = thread_get_current_thread();
58
59	ASSERT(thread->arch_info.iframes.index >= 0);
60	return thread->arch_info.iframes.frames[thread->arch_info.iframes.index - 1];
61}
62
63
64/** \brief Returns the current thread's topmost (i.e. most recent)
65 *  userland->kernel transition iframe (usually the first one, save for
66 *  interrupts in signal handlers).
67 *  \return The iframe, or \c NULL, if there is no such iframe (e.g. when
68 *          the thread is a kernel thread).
69 */
70struct iframe *
71ppc_get_user_iframe(void)
72{
73	Thread *thread = thread_get_current_thread();
74	int i;
75
76	for (i = thread->arch_info.iframes.index - 1; i >= 0; i--) {
77		struct iframe *frame = thread->arch_info.iframes.frames[i];
78		if (frame->srr1 & MSR_PRIVILEGE_LEVEL)
79			return frame;
80	}
81
82	return NULL;
83}
84
85
86// #pragma mark -
87
88
89status_t
90arch_thread_init(struct kernel_args *args)
91{
92	// Initialize the static initial arch_thread state (sInitialState).
93	// Currently nothing to do, i.e. zero initialized is just fine.
94
95	return B_OK;
96}
97
98
99status_t
100arch_team_init_team_struct(Team *team, bool kernel)
101{
102	// Nothing to do. The structure is empty.
103	return B_OK;
104}
105
106
107status_t
108arch_thread_init_thread_struct(Thread *thread)
109{
110	// set up an initial state (stack & fpu)
111	memcpy(&thread->arch_info, &sInitialState, sizeof(struct arch_thread));
112
113	return B_OK;
114}
115
116
117void
118arch_thread_init_kthread_stack(Thread* thread, void* _stack, void* _stackTop,
119	void (*function)(void*), const void* data)
120{
121#if 0
122	addr_t *kstack = (addr_t *)t->kernel_stack_base;
123	addr_t *kstackTop = (addr_t *)t->kernel_stack_top;
124
125	// clear the kernel stack
126#ifdef DEBUG_KERNEL_STACKS
127#	ifdef STACK_GROWS_DOWNWARDS
128	memset((void *)((addr_t)kstack + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE), 0,
129		KERNEL_STACK_SIZE);
130#	else
131	memset(kstack, 0, KERNEL_STACK_SIZE);
132#	endif
133#else
134	memset(kstack, 0, KERNEL_STACK_SIZE);
135#endif
136
137	// space for frame pointer and return address, and stack frames must be
138	// 16 byte aligned
139	kstackTop -= 2;
140	kstackTop = (addr_t*)((addr_t)kstackTop & ~0xf);
141
142	// LR, CR, r2, r13-r31, f13-f31, as pushed by ppc_context_switch()
143	kstackTop -= 22 + 2 * 19;
144
145	// let LR point to ppc_kernel_thread_root()
146	kstackTop[0] = (addr_t)&ppc_kernel_thread_root;
147
148	// the arguments of ppc_kernel_thread_root() are the functions to call,
149	// provided in registers r13-r15
150	kstackTop[3] = (addr_t)entry_func;
151	kstackTop[4] = (addr_t)start_func;
152	kstackTop[5] = (addr_t)exit_func;
153
154	// save this stack position
155	t->arch_info.sp = (void *)kstackTop;
156
157	return B_OK;
158#else
159	panic("arch_thread_init_kthread_stack(): Implement me!");
160#endif
161}
162
163
164status_t
165arch_thread_init_tls(Thread *thread)
166{
167	// TODO: Implement!
168	return B_OK;
169}
170
171
172void
173arch_thread_context_switch(Thread *t_from, Thread *t_to)
174{
175    // set the new kernel stack in the EAR register.
176	// this is used in the exception handler code to decide what kernel stack to
177	// switch to if the exception had happened when the processor was in user mode
178	asm("mtear  %0" :: "g"(t_to->kernel_stack_top - 8));
179
180    // switch the asids if we need to
181	if (t_to->team->address_space != NULL) {
182		// the target thread has is user space
183		if (t_from->team != t_to->team) {
184			// switching to a new address space
185			ppc_translation_map_change_asid(
186				t_to->team->address_space->TranslationMap());
187		}
188	}
189
190	ppc_context_switch(&t_from->arch_info.sp, t_to->arch_info.sp);
191}
192
193
194void
195arch_thread_dump_info(void *info)
196{
197	struct arch_thread *at = (struct arch_thread *)info;
198
199	dprintf("\tsp: %p\n", at->sp);
200}
201
202
203status_t
204arch_thread_enter_userspace(Thread *thread, addr_t entry, void *arg1, void *arg2)
205{
206	panic("arch_thread_enter_uspace(): not yet implemented\n");
207	return B_ERROR;
208}
209
210
211bool
212arch_on_signal_stack(Thread *thread)
213{
214	return false;
215}
216
217
218status_t
219arch_setup_signal_frame(Thread *thread, struct sigaction *sa,
220	struct signal_frame_data *signalFrameData)
221{
222	return B_ERROR;
223}
224
225
226int64
227arch_restore_signal_frame(struct signal_frame_data* signalFrameData)
228{
229	return 0;
230}
231
232
233
234/**	Saves everything needed to restore the frame in the child fork in the
235 *	arch_fork_arg structure to be passed to arch_restore_fork_frame().
236 *	Also makes sure to return the right value.
237 */
238
239void
240arch_store_fork_frame(struct arch_fork_arg *arg)
241{
242}
243
244
245/** Restores the frame from a forked team as specified by the provided
246 *	arch_fork_arg structure.
247 *	Needs to be called from within the child team, ie. instead of
248 *	arch_thread_enter_uspace() as thread "starter".
249 *	This function does not return to the caller, but will enter userland
250 *	in the child team at the same position where the parent team left of.
251 */
252
253void
254arch_restore_fork_frame(struct arch_fork_arg *arg)
255{
256}
257
258