Context Navigation

source: trunk/hal/tsar_mips32/core/hal_context.c @ 679

Last change on this file since 679 was 679, checked in by alain, 3 years ago
Mainly cosmetic.
File size: 21.5 KB

Line
1	/*
2	* hal_context.c - implementation of Thread Context API for TSAR-MIPS32
3	*
4	* Author Alain Greiner (2016,2017,2018,2019)
5	*
6	* Copyright (c) UPMC Sorbonne Universites
7	*
8	* This file is part of ALMOS-MKH.
9	*
10	* ALMOS-MKH.is free software; you can redistribute it and/or modify it
11	* under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; version 2.0 of the License.
13	*
14	* ALMOS-MKH.is distributed in the hope that it will be useful, but
15	* WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17	* General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with ALMOS-MKH.; if not, write to the Free Software Foundation,
21	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22	*/
23
24	#include <hal_kernel_types.h>
25	#include <hal_switch.h>
26	#include <memcpy.h>
27	#include <thread.h>
28	#include <string.h>
29	#include <process.h>
30	#include <printk.h>
31	#include <vmm.h>
32	#include <bits.h>
33	#include <core.h>
34	#include <cluster.h>
35	#include <hal_context.h>
36	#include <hal_kentry.h>
37
38	/////////////////////////////////////////////////////////////////////////////////////////
39	// Define various SR initialisation values for the TSAR-MIPS32 architecture.
40	/////////////////////////////////////////////////////////////////////////////////////////
41
42	#define SR_USR_MODE 0x0000FF13
43	#define SR_USR_MODE_FPU 0x2000FF13
44	#define SR_SYS_MODE 0x0000FF01
45
46	/////////////////////////////////////////////////////////////////////////////////////////
47	// This structure defines the CPU context for the TSAR-MIPS32 architecture.
48	// The following registers are saved/restored at each context switch:
49	// - GPR : all, but (zero, k0, k1), plus (hi, lo)
50	// - CP0 : c0_th , c0_sr , C0_epc
51	// - CP2 : c2_ptpr , C2_mode
52	//
53	// WARNING : check the two CONFIG_CPU_CTX_SIZE & CONFIG_FPU_CTX_SIZE configuration
54	// parameters when modifying this structure.
55	/////////////////////////////////////////////////////////////////////////////////////////
56
57	typedef struct hal_cpu_context_s
58	{
59	uint32_t c0_epc; // slot 0
60	uint32_t at_01; // slot 1
61	uint32_t v0_02; // slot 2
62	uint32_t v1_03; // slot 3
63	uint32_t a0_04; // slot 4
64	uint32_t a1_05; // slot 5
65	uint32_t a2_06; // slot 6
66	uint32_t a3_07; // slot 7
67
68	uint32_t t0_08; // slot 8
69	uint32_t t1_09; // slot 9
70	uint32_t t2_10; // slot 10
71	uint32_t t3_11; // slot 11
72	uint32_t t4_12; // slot 12
73	uint32_t t5_13; // slot 13
74	uint32_t t6_14; // slot 14
75	uint32_t t7_15; // slot 15
76
77	uint32_t s0_16; // slot 16
78	uint32_t s1_17; // slot 17
79	uint32_t s2_18; // slot 18
80	uint32_t s3_19; // slot 19
81	uint32_t s4_20; // slot 20
82	uint32_t s5_21; // slot 21
83	uint32_t s6_22; // slot 22
84	uint32_t s7_23; // slot 23
85
86	uint32_t t8_24; // slot 24
87	uint32_t t9_25; // slot 25
88	uint32_t hi_26; // slot 26
89	uint32_t lo_27; // slot 27
90	uint32_t gp_28; // slot 28
91	uint32_t sp_29; // slot 29
92	uint32_t s8_30; // slot 30
93	uint32_t ra_31; // slot 31
94
95	uint32_t c2_ptpr; // slot 32
96	uint32_t c2_mode; // slot 33
97
98	uint32_t c0_sr; // slot 34
99	uint32_t c0_th; // slot 35
100	}
101	hal_cpu_context_t;
102
103	/////////////////////////////////////////////////////////////////////////////////////////
104	// This structure defines the fpu_context for the TSAR MIPS32 architecture.
105	/////////////////////////////////////////////////////////////////////////////////////////
106
107	typedef struct hal_fpu_context_s
108	{
109	uint32_t fpu_regs[32];
110	}
111	hal_fpu_context_t;
112
113
114	/////////////////////////////////////////////////////////////////////////////////////////
115	// CPU context related functions
116	/////////////////////////////////////////////////////////////////////////////////////////
117
118
119	//////////////////////////////////////////////////
120	error_t hal_cpu_context_alloc( thread_t * thread )
121	{
122
123	assert( __FUNCTION__, (sizeof(hal_cpu_context_t) <= CONFIG_CPU_CTX_SIZE), "illegal CPU context size" );
124
125	// allocate memory for cpu_context
126	kmem_req_t req;
127	req.type = KMEM_KCM;
128	req.order = bits_log2( sizeof(hal_cpu_context_t) );
129	req.flags = AF_KERNEL \| AF_ZERO;
130
131	hal_cpu_context_t * context = kmem_alloc( &req );
132
133	if( context == NULL ) return -1;
134
135	// link to thread
136	thread->cpu_context = (void *)context;
137	return 0;
138
139	} // end hal_cpu_context_alloc()
140
141	//////////////////////////////////////////////////////////////////////////////
142	// The following context slots are initialised for the MIPS32 architecture
143	// GPR : a0_04 / a1_05 / sp_29 / ra_31
144	// CP0 : c0_sr / c0_th / c0_epc
145	// CP2 : c2_ptpr / c2_mode
146	//////////////////////////////////////////////////////////////////////////////
147	void hal_cpu_context_init( thread_t * thread,
148	bool_t is_main,
149	uint32_t argc,
150	intptr_t argv )
151	{
152	hal_cpu_context_t * context = (hal_cpu_context_t *)thread->cpu_context;
153
154	assert( __FUNCTION__, (context != NULL ), "CPU context not allocated" );
155
156	// compute the PPN for the GPT PT1
157	ppn_t gpt_pt1_ppn = ppm_base2ppn( XPTR( local_cxy , thread->process->vmm.gpt.ptr ) );
158
159	// initialisation depends on thread type
160	if( (thread->type == THREAD_USER) && (is_main != 0) )
161	{
162	context->a0_04 = (uint32_t)argc;
163	context->a1_05 = (uint32_t)argv;
164	context->sp_29 = (uint32_t)thread->user_stack_vseg->max - 8;
165	context->ra_31 = (uint32_t)&hal_kentry_eret;
166	context->c0_epc = (uint32_t)thread->entry_func;
167	context->c0_sr = SR_USR_MODE;
168	context->c0_th = (uint32_t)thread;
169	context->c2_ptpr = (uint32_t)(gpt_pt1_ppn >> 1);
170	context->c2_mode = 0xF;
171	}
172	else if( (thread->type == THREAD_USER) && (is_main == 0) )
173	{
174	context->a0_04 = (uint32_t)thread->entry_args;
175	context->sp_29 = (uint32_t)thread->user_stack_vseg->max - 8;
176	context->ra_31 = (uint32_t)&hal_kentry_eret;
177	context->c0_epc = (uint32_t)thread->entry_func;
178	context->c0_sr = SR_USR_MODE;
179	context->c0_th = (uint32_t)thread;
180	context->c2_ptpr = (uint32_t)(gpt_pt1_ppn >> 1);
181	context->c2_mode = 0xF;
182	}
183	else // kernel thread
184	{
185	context->a0_04 = (uint32_t)thread->entry_args;
186	context->sp_29 = (uint32_t)thread->k_stack_base + (uint32_t)thread->k_stack_size - 8;
187	context->ra_31 = (uint32_t)thread->entry_func;
188	context->c0_sr = SR_SYS_MODE;
189	context->c0_th = (uint32_t)thread;
190	context->c2_ptpr = (uint32_t)(gpt_pt1_ppn >> 1);
191	context->c2_mode = 0x3;
192	}
193
194	#if DEBUG_HAL_CONTEXT_INIT
195	hal_cpu_context_display( XPTR( local_cxy , thread ) );
196	#endif
197
198	} // end hal_cpu_context_init()
199
200	////////////////////////////////////////////
201	void hal_cpu_context_fork( xptr_t child_xp )
202	{
203	cxy_t parent_cxy; // parent thread cluster
204	thread_t * parent_ptr; // local pointer on parent thread
205	hal_cpu_context_t * parent_context; // local pointer on parent cpu_context
206	uint32_t * parent_uzone; // local_pointer on parent uzone (in kernel stack)
207	char * parent_ksp; // kernel stack pointer on parent kernel stack
208	uint32_t parent_us_base; // parent user stack base value
209
210	cxy_t child_cxy; // parent thread cluster
211	thread_t * child_ptr; // local pointer on child thread
212	hal_cpu_context_t * child_context; // local pointer on child cpu_context
213	uint32_t * child_uzone; // local_pointer on child uzone (in kernel stack)
214	char * child_ksp; // kernel stack pointer on child kernel stack
215	uint32_t child_us_base; // child user stack base value
216
217	process_t * child_process; // local pointer on child processs
218	void * child_gpt_ptr; // local pointer on child GPT PT1
219	uint32_t child_gpt_ppn; // PPN of child GPT PT1
220	vseg_t * child_us_vseg; // local pointer on child user stack vseg
221
222	// allocate a local CPU context in parent kernel stack
223	hal_cpu_context_t context;
224
225	// get (local) parent thread cluster and local pointer
226	parent_cxy = local_cxy;
227	parent_ptr = CURRENT_THREAD;
228
229	// get (remote) child thread cluster and local pointer
230	child_cxy = GET_CXY( child_xp );
231	child_ptr = GET_PTR( child_xp );
232
233	// get local pointer on (local) parent CPU context
234	parent_context = parent_ptr->cpu_context;
235
236	// get local pointer on (remote) child CPU context
237	child_context = hal_remote_lpt( XPTR(child_cxy , &child_ptr->cpu_context) );
238
239	// get local pointer on remote child process
240	child_process = hal_remote_lpt( XPTR(child_cxy , &child_ptr->process) );
241
242	// get base and ppn of remote child process GPT PT1
243	child_gpt_ptr = hal_remote_lpt( XPTR(child_cxy , &child_process->vmm.gpt.ptr) );
244	child_gpt_ppn = ppm_base2ppn( XPTR( child_cxy , child_gpt_ptr ) );
245
246	// get local pointer on local parent uzone (in parent kernel stack)
247	parent_uzone = parent_ptr->uzone_current;
248
249	// compute local pointer on remote child uzone (in child kernel stack)
250	child_uzone = (uint32_t *)( (intptr_t)parent_uzone +
251	(intptr_t)child_ptr -
252	(intptr_t)parent_ptr );
253
254	// update the uzone pointer in child thread descriptor
255	hal_remote_spt( XPTR( child_cxy , &child_ptr->uzone_current ) , child_uzone );
256
257	#if DEBUG_HAL_CONTEXT_FORK
258	uint32_t cycle = (uint32_t)hal_get_cycles();
259	if( DEBUG_HAL_CONTEXT_FORK < cycle )
260	printk("\n[%s] thread[%x,%x] parent_uzone %x / child_uzone %x / cycle %d\n",
261	__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_uzone, child_uzone, cycle );
262	#endif
263
264	// get user stack base for parent thread
265	parent_us_base = parent_ptr->user_stack_vseg->min;
266
267	// get user stack base for child thread
268	child_us_vseg = hal_remote_lpt( XPTR( child_cxy , &child_ptr->user_stack_vseg ) );
269	child_us_base = hal_remote_l32( XPTR( child_cxy , &child_us_vseg->min ) );
270
271	#if DEBUG_HAL_CONTEXT_FORK
272	if( DEBUG_HAL_CONTEXT_FORK < cycle )
273	printk("\n[%s] thread[%x,%x] parent_ustack_base %x / child_ustack_base %x\n",
274	__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_us_base, child_us_base );
275	#endif
276
277	// get current value of kernel stack pointer in parent kernel stack
278	parent_ksp = (char *)hal_get_sp();
279
280	// compute value of kernel stack pointer in child kernel stack
281	child_ksp = (char *)((intptr_t)parent_ksp +
282	(intptr_t)child_ptr -
283	(intptr_t)parent_ptr );
284
285	#if DEBUG_HAL_CONTEXT_FORK
286	if( DEBUG_HAL_CONTEXT_FORK < cycle )
287	printk("\n[%s] thread[%x,%x] parent_ksp %x / child_ksp %x\n",
288	__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_ksp, child_ksp );
289	#endif
290
291	// compute number of bytes to be copied, depending on current value of parent_ksp
292	uint32_t size = (uint32_t)parent_ptr + CONFIG_THREAD_DESC_SIZE - (uint32_t)parent_ksp;
293
294	// copy parent kernel stack content to child thread descriptor
295	// (this includes the uzone, that is allocated in the kernel stack)
296	hal_remote_memcpy( XPTR( child_cxy , child_ksp ),
297	XPTR( local_cxy , parent_ksp ),
298	size );
299
300	#if DEBUG_HAL_CONTEXT_FORK
301	if( DEBUG_HAL_CONTEXT_FORK < cycle )
302	printk("\n[%s] thread[%x,%x] copied kstack from parent (%x) to child (%x)\n",
303	__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_ptr, child_ptr );
304	#endif
305
306	// save current values of CPU registers to local copy of CPU context
307	hal_do_cpu_save( &context );
308
309	// update three slots in this local CPU context
310	context.sp_29 = (uint32_t)child_ksp;
311	context.c0_th = (uint32_t)child_ptr;
312	context.c2_ptpr = (uint32_t)child_gpt_ppn >> 1;
313
314	// From this point, both parent and child execute the following code,
315	// but child thread will only execute it after being unblocked by parent thread.
316	// They can be distinguished by the (CURRENT_THREAD,local_cxy) values,
317	// and we must re-initialise the calling thread pointer from c0_th register
318
319	thread_t * this = CURRENT_THREAD;
320
321	if( (this == parent_ptr) && (local_cxy == parent_cxy) ) // parent thread
322	{
323	// parent thread must update four slots in child uzone
324	// - UZ_TH : parent and child have different threads descriptors
325	// - UZ_SP : parent and child have different user stack base addresses.
326	// - UZ_PTPR : parent and child use different Generic Page Tables
327
328	// parent thread computes values for child thread
329	uint32_t child_sp = parent_uzone[UZ_SP] + child_us_base - parent_us_base;
330	uint32_t child_th = (uint32_t)child_ptr;
331	uint32_t child_ptpr = (uint32_t)child_gpt_ppn >> 1;
332
333	#if DEBUG_HAL_CONTEXT_FORK
334	if( DEBUG_HAL_CONTEXT_FORK < cycle )
335	printk("\n[%s] thread[%x,%x] : parent_uz_sp %x / child_uz_sp %x\n",
336	__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid,
337	parent_uzone[UZ_SP], child_sp );
338	#endif
339
340	// parent thread updates the child uzone
341	hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_SP] ) , child_sp );
342	hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_TH] ) , child_th );
343	hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_PTPR] ) , child_ptpr );
344
345	// parent thread copies the local context to remote child context
346	hal_remote_memcpy( XPTR( child_cxy , child_context ),
347	XPTR( local_cxy , &context ) ,
348	sizeof( hal_cpu_context_t ) );
349	#if DEBUG_HAL_CONTEXT_FORK
350	if( DEBUG_HAL_CONTEXT_FORK < cycle )
351	printk("\n[%s] thread[%x,%x] copied parent CPU context to child CPU context\n",
352	__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid );
353	#endif
354
355	// parent thread unblocks child thread
356	thread_unblock( XPTR( child_cxy , child_ptr ) , THREAD_BLOCKED_GLOBAL );
357
358	#if DEBUG_HAL_CONTEXT_FORK
359	cycle = (uint32_t)hal_get_cycles();
360	trdid_t child_trdid = hal_remote_l32( XPTR( child_cxy , &child_ptr->trdid ) );
361	pid_t child_pid = hal_remote_l32( XPTR( child_cxy , &child_process->pid ) );
362	printk("\n[%s] thread[%x,%x] unblocked child thread[%x,%x] / cycle %d\n",
363	__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, child_pid, child_trdid, cycle );
364	#endif
365
366	}
367
368	} // end hal_cpu_context_fork()
369
370	/////////////////////////////////////////////////
371	void hal_cpu_context_display( xptr_t thread_xp )
372	{
373	hal_cpu_context_t * ctx;
374
375	// get thread cluster and local pointer
376	cxy_t cxy = GET_CXY( thread_xp );
377	thread_t * ptr = GET_PTR( thread_xp );
378
379	// get context pointer
380	ctx = (hal_cpu_context_t *)hal_remote_lpt( XPTR( cxy , &ptr->cpu_context ) );
381
382	// get relevant context slots values
383	uint32_t sp_29 = hal_remote_l32( XPTR( cxy , &ctx->sp_29 ) );
384	uint32_t ra_31 = hal_remote_l32( XPTR( cxy , &ctx->ra_31 ) );
385	uint32_t a0_04 = hal_remote_l32( XPTR( cxy , &ctx->a0_04 ) );
386	uint32_t a1_05 = hal_remote_l32( XPTR( cxy , &ctx->a1_05 ) );
387	uint32_t c0_sr = hal_remote_l32( XPTR( cxy , &ctx->c0_sr ) );
388	uint32_t c0_epc = hal_remote_l32( XPTR( cxy , &ctx->c0_epc ) );
389	uint32_t c0_th = hal_remote_l32( XPTR( cxy , &ctx->c0_th ) );
390	uint32_t c2_ptpr = hal_remote_l32( XPTR( cxy , &ctx->c2_ptpr ) );
391	uint32_t c2_mode = hal_remote_l32( XPTR( cxy , &ctx->c2_mode ) );
392
393	printk("\n***** CPU context for thread %x in process %x / cycle %d\n"
394	" sp_29 = %X ra_31 = %X a0_04 = %X a1_05 = %X\n"
395	" c0_sr = %X c0_epc = %X c0_th = %X\n"
396	" c2_ptpr = %X c2_mode = %X\n",
397	ptr, ptr->process->pid, (uint32_t)hal_get_cycles(),
398	sp_29 , ra_31 , a0_04 , a1_05,
399	c0_sr , c0_epc , c0_th,
400	c2_ptpr , c2_mode );
401
402	} // end hal_cpu_context_display()
403
404	/////////////////////////////////////////////////
405	void hal_cpu_context_destroy( thread_t * thread )
406	{
407	kmem_req_t req;
408
409	hal_cpu_context_t * ctx = thread->cpu_context;
410
411	// release CPU context if required
412	if( ctx != NULL )
413	{
414	req.type = KMEM_KCM;
415	req.ptr = ctx;
416	kmem_free( &req );
417	}
418
419	} // end hal_cpu_context_destroy()
420
421
422
423
424
425
426
427
428
429	//////////////////////////////////////////////////
430	error_t hal_fpu_context_alloc( thread_t * thread )
431	{
432	assert( __FUNCTION__, (sizeof(hal_fpu_context_t) <= CONFIG_FPU_CTX_SIZE) ,
433	"illegal CPU context size" );
434
435	// allocate memory for fpu_context
436	kmem_req_t req;
437	req.type = KMEM_KCM;
438	req.flags = AF_KERNEL \| AF_ZERO;
439	req.order = bits_log2( sizeof(hal_fpu_context_t) );
440
441	hal_fpu_context_t * context = kmem_alloc( &req );
442
443	if( context == NULL ) return -1;
444
445	// link to thread
446	thread->fpu_context = (void *)context;
447	return 0;
448
449	} // end hal_fpu_context_alloc()
450
451	//////////////////////////////////////////////
452	void hal_fpu_context_init( thread_t * thread )
453	{
454	hal_fpu_context_t * context = thread->fpu_context;
455
456	assert( __FUNCTION__, (context != NULL) , "fpu context not allocated" );
457
458	memset( context , 0 , sizeof(hal_fpu_context_t) );
459	}
460
461	//////////////////////////////////////////
462	void hal_fpu_context_copy( thread_t * dst,
463	thread_t * src )
464	{
465	assert( __FUNCTION__, (src != NULL) , "src thread pointer is NULL\n");
466	assert( __FUNCTION__, (dst != NULL) , "dst thread pointer is NULL\n");
467
468	// get fpu context pointers
469	hal_fpu_context_t * src_context = src->fpu_context;
470	hal_fpu_context_t * dst_context = dst->fpu_context;
471
472	// copy CPU context from src to dst
473	memcpy( dst_context , src_context , sizeof(hal_fpu_context_t) );
474
475	} // end hal_fpu_context_copy()
476
477	/////////////////////////////////////////////////
478	void hal_fpu_context_destroy( thread_t * thread )
479	{
480	kmem_req_t req;
481
482	hal_fpu_context_t * context = thread->fpu_context;
483
484	// release FPU context if required
485	if( context != NULL )
486	{
487	req.type = KMEM_KCM;
488	req.ptr = context;
489	kmem_free( &req );
490	}
491
492	} // end hal_fpu_context_destroy()
493
494	//////////////////////////////////////////////
495	void hal_fpu_context_save( xptr_t thread_xp )
496	{
497	// allocate a local FPU context in kernel stack
498	hal_fpu_context_t src_context;
499
500	// get remote child cluster and local pointer
501	cxy_t thread_cxy = GET_CXY( thread_xp );
502	thread_t * thread_ptr = GET_PTR( thread_xp );
503
504	asm volatile(
505	".set noreorder \n"
506	"swc1 $f0, 0*4(%0) \n"
507	"swc1 $f1, 1*4(%0) \n"
508	"swc1 $f2, 2*4(%0) \n"
509	"swc1 $f3, 3*4(%0) \n"
510	"swc1 $f4, 4*4(%0) \n"
511	"swc1 $f5, 5*4(%0) \n"
512	"swc1 $f6, 6*4(%0) \n"
513	"swc1 $f7, 7*4(%0) \n"
514	"swc1 $f8, 8*4(%0) \n"
515	"swc1 $f9, 9*4(%0) \n"
516	"swc1 $f10, 10*4(%0) \n"
517	"swc1 $f11, 11*4(%0) \n"
518	"swc1 $f12, 12*4(%0) \n"
519	"swc1 $f13, 13*4(%0) \n"
520	"swc1 $f14, 14*4(%0) \n"
521	"swc1 $f15, 15*4(%0) \n"
522	"swc1 $f16, 16*4(%0) \n"
523	"swc1 $f17, 17*4(%0) \n"
524	"swc1 $f18, 18*4(%0) \n"
525	"swc1 $f19, 19*4(%0) \n"
526	"swc1 $f20, 20*4(%0) \n"
527	"swc1 $f21, 21*4(%0) \n"
528	"swc1 $f22, 22*4(%0) \n"
529	"swc1 $f23, 23*4(%0) \n"
530	"swc1 $f24, 24*4(%0) \n"
531	"swc1 $f25, 25*4(%0) \n"
532	"swc1 $f26, 26*4(%0) \n"
533	"swc1 $f27, 27*4(%0) \n"
534	"swc1 $f28, 28*4(%0) \n"
535	"swc1 $f29, 29*4(%0) \n"
536	"swc1 $f30, 30*4(%0) \n"
537	"swc1 $f31, 31*4(%0) \n"
538	".set reorder \n"
539	: : "r"(&src_context) );
540
541	// get local pointer on target thread FPU context
542	void * dst_context = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->fpu_context ) );
543
544	// copy local context to remote child context)
545	hal_remote_memcpy( XPTR( thread_cxy , dst_context ),
546	XPTR( local_cxy , &src_context ),
547	sizeof( hal_fpu_context_t ) );
548
549	} // end hal_fpu_context_save()
550
551	/////////////////////////////////////////////////
552	void hal_fpu_context_restore( thread_t * thread )
553	{
554	// get pointer on FPU context and cast to uint32_t
555	uint32_t ctx = (uint32_t)thread->fpu_context;
556
557	asm volatile(
558	".set noreorder \n"
559	"lwc1 $f0, 0*4(%0) \n"
560	"lwc1 $f1, 1*4(%0) \n"
561	"lwc1 $f2, 2*4(%0) \n"
562	"lwc1 $f3, 3*4(%0) \n"
563	"lwc1 $f4, 4*4(%0) \n"
564	"lwc1 $f5, 5*4(%0) \n"
565	"lwc1 $f6, 6*4(%0) \n"
566	"lwc1 $f7, 7*4(%0) \n"
567	"lwc1 $f8, 8*4(%0) \n"
568	"lwc1 $f9, 9*4(%0) \n"
569	"lwc1 $f10, 10*4(%0) \n"
570	"lwc1 $f11, 11*4(%0) \n"
571	"lwc1 $f12, 12*4(%0) \n"
572	"lwc1 $f13, 13*4(%0) \n"
573	"lwc1 $f14, 14*4(%0) \n"
574	"lwc1 $f15, 15*4(%0) \n"
575	"lwc1 $f16, 16*4(%0) \n"
576	"lwc1 $f17, 17*4(%0) \n"
577	"lwc1 $f18, 18*4(%0) \n"
578	"lwc1 $f19, 19*4(%0) \n"
579	"lwc1 $f20, 20*4(%0) \n"
580	"lwc1 $f21, 21*4(%0) \n"
581	"lwc1 $f22, 22*4(%0) \n"
582	"lwc1 $f23, 23*4(%0) \n"
583	"lwc1 $f24, 24*4(%0) \n"
584	"lwc1 $f25, 25*4(%0) \n"
585	"lwc1 $f26, 26*4(%0) \n"
586	"lwc1 $f27, 27*4(%0) \n"
587	"lwc1 $f28, 28*4(%0) \n"
588	"lwc1 $f29, 29*4(%0) \n"
589	"lwc1 $f30, 30*4(%0) \n"
590	"lwc1 $f31, 31*4(%0) \n"
591	".set reorder \n"
592	: : "r"(ctx) );
593
594	} // end hal_cpu_context_restore()
595
596

Note: See TracBrowser for help on using the repository browser.

Download in other formats: