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

Last change on this file was 686, checked in by alain, 11 months ago

cosmetic

File size: 21.4 KB
Line 
1/*
2 * hal_context.c - implementation of Thread Context API for TSAR-MIPS32
3 *
4 * Author  Alain Greiner    (2016,2017,2018,2019,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
57typedef 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} 
101hal_cpu_context_t;
102
103/////////////////////////////////////////////////////////////////////////////////////////
104// This structure defines the fpu_context for the TSAR MIPS32 architecture.
105/////////////////////////////////////////////////////////////////////////////////////////
106
107typedef struct hal_fpu_context_s
108{
109        uint32_t   fpu_regs[32];     
110}
111hal_fpu_context_t;
112
113
114/////////////////////////////////////////////////////////////////////////////////////////
115//        CPU context related functions
116/////////////////////////////////////////////////////////////////////////////////////////
117
118
119//////////////////////////////////////////////////
120error_t hal_cpu_context_alloc( thread_t * thread )
121{
122
123assert( __FUNCTION__, (sizeof(hal_cpu_context_t) <= CONFIG_CPU_CTX_SIZE),
124"illegal CPU context size" );
125
126    // allocate memory for cpu_context
127    hal_cpu_context_t * context = kmem_alloc( bits_log2( sizeof(hal_cpu_context_t) ),
128                                              AF_KERNEL | AF_ZERO);
129    if( context == NULL ) return -1;
130
131    // link to thread
132    thread->cpu_context = (void *)context;
133    return 0;
134
135}   // end hal_cpu_context_alloc()
136
137//////////////////////////////////////////////////////////////////////////////
138// The following context slots are initialised for the MIPS32 architecture
139// GPR : a0_04 / a1_05 / sp_29 / ra_31
140// CP0 : c0_sr / c0_th / c0_epc
141// CP2 : c2_ptpr / c2_mode
142//////////////////////////////////////////////////////////////////////////////
143void hal_cpu_context_init( thread_t * thread,
144                           bool_t     is_main,
145                           uint32_t   argc,
146                           intptr_t   argv )
147{
148    hal_cpu_context_t * context = (hal_cpu_context_t *)thread->cpu_context;
149
150assert( __FUNCTION__, (context != NULL ), 
151"CPU context not allocated" );
152
153    // compute the PPN for the GPT PT1
154    ppn_t    gpt_pt1_ppn = ppm_base2ppn( XPTR( local_cxy , thread->process->vmm.gpt.ptr ) );
155
156    // initialisation depends on thread type
157    if( (thread->type == THREAD_USER) && (is_main != 0) )
158    {
159        context->a0_04   = (uint32_t)argc;
160        context->a1_05   = (uint32_t)argv;
161        context->sp_29   = (uint32_t)thread->user_stack_vseg->max - 8;
162        context->ra_31   = (uint32_t)&hal_kentry_eret;
163        context->c0_epc  = (uint32_t)thread->entry_func;
164        context->c0_sr   = SR_USR_MODE;
165            context->c0_th   = (uint32_t)thread; 
166            context->c2_ptpr = (uint32_t)(gpt_pt1_ppn >> 1);
167        context->c2_mode = 0xF;
168    }
169    else if( (thread->type == THREAD_USER) && (is_main == 0) )
170    {
171        context->a0_04   = (uint32_t)thread->entry_args;
172        context->sp_29   = (uint32_t)thread->user_stack_vseg->max - 8;
173        context->ra_31   = (uint32_t)&hal_kentry_eret;
174        context->c0_epc  = (uint32_t)thread->entry_func;
175        context->c0_sr   = SR_USR_MODE;
176            context->c0_th   = (uint32_t)thread; 
177            context->c2_ptpr = (uint32_t)(gpt_pt1_ppn >> 1);
178        context->c2_mode = 0xF;
179    }
180    else  // kernel thread
181    {
182        context->a0_04   = (uint32_t)thread->entry_args;
183        context->sp_29   = (uint32_t)thread->k_stack_base + (uint32_t)thread->k_stack_size - 8;
184        context->ra_31   = (uint32_t)thread->entry_func;
185        context->c0_sr   = SR_SYS_MODE;
186            context->c0_th   = (uint32_t)thread; 
187            context->c2_ptpr = (uint32_t)(gpt_pt1_ppn >> 1);
188        context->c2_mode = 0x3;
189    }
190
191#if DEBUG_HAL_CONTEXT_INIT
192hal_cpu_context_display( XPTR( local_cxy , thread ) );
193#endif
194
195}  // end hal_cpu_context_init()
196
197////////////////////////////////////////////
198void hal_cpu_context_fork( xptr_t child_xp )
199{
200    cxy_t               parent_cxy;        // parent thread cluster
201    thread_t          * parent_ptr;        // local pointer on parent thread
202    hal_cpu_context_t * parent_context;    // local pointer on parent cpu_context
203    uint32_t          * parent_uzone;      // local_pointer on parent uzone (in kernel stack)
204    char              * parent_ksp;        // kernel stack pointer on parent kernel stack
205    uint32_t            parent_us_base;    // parent user stack base value
206
207    cxy_t               child_cxy;         // parent thread cluster
208    thread_t          * child_ptr;         // local pointer on child thread
209    hal_cpu_context_t * child_context;     // local pointer on child cpu_context
210    uint32_t          * child_uzone;       // local_pointer on child uzone (in kernel stack)
211    char              * child_ksp;         // kernel stack pointer on child kernel stack
212    uint32_t            child_us_base;     // child user stack base value
213
214    process_t         * child_process;     // local pointer on child processs
215    void              * child_gpt_ptr;     // local pointer on child GPT PT1
216    uint32_t            child_gpt_ppn;     // PPN of child GPT PT1
217    vseg_t            * child_us_vseg;     // local pointer on child user stack vseg
218   
219    // allocate a local CPU context in parent kernel stack
220    hal_cpu_context_t context;
221
222    // get (local) parent thread cluster and local pointer
223    parent_cxy = local_cxy;
224    parent_ptr = CURRENT_THREAD;
225
226    // get (remote) child thread cluster and local pointer
227    child_cxy = GET_CXY( child_xp );
228    child_ptr = GET_PTR( child_xp );
229
230    // get local pointer on (local) parent CPU context
231    parent_context = parent_ptr->cpu_context;
232
233    // get local pointer on (remote) child CPU context
234    child_context = hal_remote_lpt( XPTR(child_cxy , &child_ptr->cpu_context) );
235
236    // get local pointer on remote child process
237    child_process = hal_remote_lpt( XPTR(child_cxy , &child_ptr->process) );
238
239    // get base and ppn of remote child process GPT PT1
240    child_gpt_ptr = hal_remote_lpt( XPTR(child_cxy , &child_process->vmm.gpt.ptr) );
241    child_gpt_ppn = ppm_base2ppn( XPTR( child_cxy , child_gpt_ptr ) );   
242
243    // get local pointer on local parent uzone (in parent kernel stack)
244    parent_uzone = parent_ptr->uzone_current;
245
246    // compute local pointer on remote child uzone (in child kernel stack)
247    child_uzone  = (uint32_t *)( (intptr_t)parent_uzone +
248                                 (intptr_t)child_ptr    -
249                                 (intptr_t)parent_ptr  );
250
251    // update the uzone pointer in child thread descriptor
252    hal_remote_spt( XPTR( child_cxy , &child_ptr->uzone_current ) , child_uzone );
253
254#if DEBUG_HAL_CONTEXT_FORK
255uint32_t cycle = (uint32_t)hal_get_cycles();
256if( DEBUG_HAL_CONTEXT_FORK < cycle )
257printk("\n[%s] thread[%x,%x] parent_uzone %x / child_uzone %x / cycle %d\n",
258__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_uzone, child_uzone, cycle );
259#endif
260
261    // get user stack base for parent thread
262    parent_us_base = parent_ptr->user_stack_vseg->min;
263
264    // get user stack base for child thread
265    child_us_vseg  = hal_remote_lpt( XPTR( child_cxy , &child_ptr->user_stack_vseg ) );
266    child_us_base  = hal_remote_l32( XPTR( child_cxy , &child_us_vseg->min ) );
267
268#if DEBUG_HAL_CONTEXT_FORK
269if( DEBUG_HAL_CONTEXT_FORK < cycle )
270printk("\n[%s] thread[%x,%x] parent_ustack_base %x / child_ustack_base %x\n",
271__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_us_base, child_us_base );
272#endif
273
274    // get current value of kernel stack pointer in parent kernel stack
275    parent_ksp = (char *)hal_get_sp();
276
277    // compute value of kernel stack pointer in child kernel stack
278    child_ksp  = (char *)((intptr_t)parent_ksp +
279                          (intptr_t)child_ptr  - 
280                          (intptr_t)parent_ptr );
281
282#if DEBUG_HAL_CONTEXT_FORK
283if( DEBUG_HAL_CONTEXT_FORK < cycle )
284printk("\n[%s] thread[%x,%x] parent_ksp %x / child_ksp %x\n",
285__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_ksp, child_ksp );
286#endif
287
288    // compute number of bytes to be copied, depending on current value of parent_ksp
289    uint32_t size = (uint32_t)parent_ptr + CONFIG_THREAD_DESC_SIZE - (uint32_t)parent_ksp;   
290
291    // copy parent kernel stack content to child thread descriptor
292    // (this includes the uzone, that is allocated in the kernel stack)
293    hal_remote_memcpy( XPTR( child_cxy , child_ksp ),
294                       XPTR( local_cxy , parent_ksp ),
295                       size );
296
297#if DEBUG_HAL_CONTEXT_FORK
298if( DEBUG_HAL_CONTEXT_FORK < cycle )
299printk("\n[%s] thread[%x,%x] copied kstack from parent (%x) to child (%x)\n",
300__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_ptr, child_ptr );
301#endif
302
303    // save current values of CPU registers to local copy of CPU context
304    hal_do_cpu_save( &context );
305
306    // update  three slots in this local CPU context
307    context.sp_29   = (uint32_t)child_ksp;
308    context.c0_th   = (uint32_t)child_ptr;
309    context.c2_ptpr = (uint32_t)child_gpt_ppn >> 1;
310
311    // From this point, both parent and child execute the following code,
312    // but child thread will only execute it after being unblocked by parent thread.
313    // They can be distinguished by the (CURRENT_THREAD,local_cxy) values,
314    // and we must re-initialise the calling thread pointer from c0_th register
315
316    thread_t * this = CURRENT_THREAD;
317
318    if( (this == parent_ptr) && (local_cxy == parent_cxy) )   // parent thread
319    {
320        // parent thread must update four slots in child uzone
321        // - UZ_TH   : parent and child have different threads descriptors
322        // - UZ_SP   : parent and child have different user stack base addresses.
323        // - UZ_PTPR : parent and child use different Generic Page Tables
324
325        // parent thread computes values for child thread
326        uint32_t child_sp    = parent_uzone[UZ_SP]  + child_us_base - parent_us_base;
327        uint32_t child_th    = (uint32_t)child_ptr;
328        uint32_t child_ptpr  = (uint32_t)child_gpt_ppn >> 1;
329
330#if DEBUG_HAL_CONTEXT_FORK
331if( DEBUG_HAL_CONTEXT_FORK < cycle )
332printk("\n[%s] thread[%x,%x] : parent_uz_sp %x / child_uz_sp %x\n",
333__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid,
334parent_uzone[UZ_SP], child_sp );
335#endif
336
337        // parent thread updates the child uzone
338        hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_SP]   ) , child_sp );
339        hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_TH]   ) , child_th );
340        hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_PTPR] ) , child_ptpr );
341
342        // parent thread copies the local context to remote child context
343        hal_remote_memcpy( XPTR( child_cxy , child_context ),
344                           XPTR( local_cxy  , &context ) , 
345                           sizeof( hal_cpu_context_t ) );
346#if DEBUG_HAL_CONTEXT_FORK
347if( DEBUG_HAL_CONTEXT_FORK < cycle )
348printk("\n[%s] thread[%x,%x] copied parent CPU context to child CPU context\n",
349__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid );
350#endif
351
352        // parent thread unblocks child thread
353        thread_unblock( XPTR( child_cxy , child_ptr ) , THREAD_BLOCKED_GLOBAL );
354
355#if DEBUG_HAL_CONTEXT_FORK
356cycle = (uint32_t)hal_get_cycles();
357trdid_t child_trdid = hal_remote_l32( XPTR( child_cxy , &child_ptr->trdid ) );
358pid_t   child_pid   = hal_remote_l32( XPTR( child_cxy , &child_process->pid ) );
359printk("\n[%s] thread[%x,%x] unblocked child thread[%x,%x] / cycle %d\n",
360__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, child_pid, child_trdid, cycle );
361#endif
362
363    }
364
365}  // end hal_cpu_context_fork()
366
367/////////////////////////////////////////////////
368void hal_cpu_context_display( xptr_t  thread_xp )
369{
370    hal_cpu_context_t * ctx;
371
372    // get thread cluster and local pointer
373    cxy_t      cxy = GET_CXY( thread_xp );
374    thread_t * ptr = GET_PTR( thread_xp );
375
376    // get context pointer
377    ctx = (hal_cpu_context_t *)hal_remote_lpt( XPTR( cxy , &ptr->cpu_context ) );
378
379    // get relevant context slots values
380    uint32_t sp_29   = hal_remote_l32( XPTR( cxy , &ctx->sp_29   ) );
381    uint32_t ra_31   = hal_remote_l32( XPTR( cxy , &ctx->ra_31   ) );
382    uint32_t a0_04   = hal_remote_l32( XPTR( cxy , &ctx->a0_04   ) );
383    uint32_t a1_05   = hal_remote_l32( XPTR( cxy , &ctx->a1_05   ) );
384    uint32_t c0_sr   = hal_remote_l32( XPTR( cxy , &ctx->c0_sr   ) );
385    uint32_t c0_epc  = hal_remote_l32( XPTR( cxy , &ctx->c0_epc  ) );
386    uint32_t c0_th   = hal_remote_l32( XPTR( cxy , &ctx->c0_th   ) );
387    uint32_t c2_ptpr = hal_remote_l32( XPTR( cxy , &ctx->c2_ptpr ) );
388    uint32_t c2_mode = hal_remote_l32( XPTR( cxy , &ctx->c2_mode ) );
389   
390    printk("\n***** CPU context for thread %x in process %x / cycle %d\n" 
391           " sp_29   = %X  ra_31   = %X  a0_04 = %X   a1_05 = %X\n" 
392           " c0_sr   = %X  c0_epc  = %X  c0_th = %X\n"
393           " c2_ptpr = %X  c2_mode = %X\n",
394           ptr, ptr->process->pid, (uint32_t)hal_get_cycles(),
395           sp_29   , ra_31   , a0_04 , a1_05,
396           c0_sr   , c0_epc  , c0_th,
397           c2_ptpr , c2_mode );
398
399}  // end hal_cpu_context_display()
400
401/////////////////////////////////////////////////
402void hal_cpu_context_destroy( thread_t * thread )
403{
404    // get pointer on CPU context
405    hal_cpu_context_t * ctx = thread->cpu_context;
406
407    // release CPU context if required
408    if( ctx != NULL )  kmem_free( ctx , bits_log2( sizeof(hal_cpu_context_t)) );
409
410}  // end hal_cpu_context_destroy()
411
412
413
414
415
416
417
418
419
420//////////////////////////////////////////////////
421error_t hal_fpu_context_alloc( thread_t * thread )
422{
423    assert( __FUNCTION__, (sizeof(hal_fpu_context_t) <= CONFIG_FPU_CTX_SIZE) ,
424    "illegal CPU context size" );
425
426    // allocate memory for fpu_context
427    hal_fpu_context_t * context = kmem_alloc( bits_log2( sizeof(hal_fpu_context_t) ),
428                                              AF_KERNEL | AF_ZERO );
429
430    if( context == NULL ) return -1;
431
432    // link to thread
433    thread->fpu_context = (void *)context;
434    return 0;
435
436}   // end hal_fpu_context_alloc()
437
438//////////////////////////////////////////////
439void hal_fpu_context_init( thread_t * thread )
440{
441    hal_fpu_context_t * context = thread->fpu_context;
442
443assert( __FUNCTION__, (context != NULL) , 
444"fpu context not allocated" );
445
446    memset( context , 0 , sizeof(hal_fpu_context_t) );
447}
448
449//////////////////////////////////////////
450void hal_fpu_context_copy( thread_t * dst,
451                           thread_t * src )
452{
453    assert( __FUNCTION__, (src != NULL) , "src thread pointer is NULL\n");
454    assert( __FUNCTION__, (dst != NULL) , "dst thread pointer is NULL\n");
455
456    // get fpu context pointers
457    hal_fpu_context_t * src_context = src->fpu_context;
458    hal_fpu_context_t * dst_context = dst->fpu_context;
459
460    // copy CPU context from src to dst
461    memcpy( dst_context , src_context , sizeof(hal_fpu_context_t) );
462
463}  // end hal_fpu_context_copy()
464
465/////////////////////////////////////////////////
466void hal_fpu_context_destroy( thread_t * thread )
467{
468    // get pointer on FPU context
469    hal_fpu_context_t * ctx = thread->fpu_context;
470
471    // release FPU context if required
472    if( ctx != NULL ) kmem_free( ctx , bits_log2( sizeof(hal_fpu_context_t)) );
473
474}  // end hal_fpu_context_destroy()
475
476//////////////////////////////////////////////
477void hal_fpu_context_save( xptr_t  thread_xp )
478{
479    // allocate a local FPU context in kernel stack
480    hal_fpu_context_t  src_context;
481
482    // get remote child cluster and local pointer
483    cxy_t      thread_cxy = GET_CXY( thread_xp );
484    thread_t * thread_ptr = GET_PTR( thread_xp );
485
486    asm volatile(
487    ".set noreorder           \n"
488    "swc1    $f0,    0*4(%0)  \n"   
489    "swc1    $f1,    1*4(%0)  \n"   
490    "swc1    $f2,    2*4(%0)  \n"   
491    "swc1    $f3,    3*4(%0)  \n"   
492    "swc1    $f4,    4*4(%0)  \n"   
493    "swc1    $f5,    5*4(%0)  \n"   
494    "swc1    $f6,    6*4(%0)  \n"   
495    "swc1    $f7,    7*4(%0)  \n"   
496    "swc1    $f8,    8*4(%0)  \n"   
497    "swc1    $f9,    9*4(%0)  \n"   
498    "swc1    $f10,  10*4(%0)  \n"   
499    "swc1    $f11,  11*4(%0)  \n"   
500    "swc1    $f12,  12*4(%0)  \n"   
501    "swc1    $f13,  13*4(%0)  \n"   
502    "swc1    $f14,  14*4(%0)  \n"   
503    "swc1    $f15,  15*4(%0)  \n"   
504    "swc1    $f16,  16*4(%0)  \n"   
505    "swc1    $f17,  17*4(%0)  \n"   
506    "swc1    $f18,  18*4(%0)  \n"   
507    "swc1    $f19,  19*4(%0)  \n"   
508    "swc1    $f20,  20*4(%0)  \n"   
509    "swc1    $f21,  21*4(%0)  \n"   
510    "swc1    $f22,  22*4(%0)  \n"   
511    "swc1    $f23,  23*4(%0)  \n"   
512    "swc1    $f24,  24*4(%0)  \n"   
513    "swc1    $f25,  25*4(%0)  \n"   
514    "swc1    $f26,  26*4(%0)  \n"   
515    "swc1    $f27,  27*4(%0)  \n"   
516    "swc1    $f28,  28*4(%0)  \n"   
517    "swc1    $f29,  29*4(%0)  \n"   
518    "swc1    $f30,  30*4(%0)  \n"   
519    "swc1    $f31,  31*4(%0)  \n"   
520    ".set reorder             \n"
521    : : "r"(&src_context) );
522
523    // get local pointer on target thread FPU context
524    void * dst_context = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->fpu_context ) );
525
526    // copy local context to remote child context)
527    hal_remote_memcpy( XPTR( thread_cxy , dst_context ),
528                       XPTR( local_cxy  , &src_context ), 
529                       sizeof( hal_fpu_context_t ) );
530
531}  // end hal_fpu_context_save()
532
533/////////////////////////////////////////////////
534void hal_fpu_context_restore( thread_t * thread )
535{
536    // get pointer on FPU context and cast to uint32_t
537    uint32_t ctx = (uint32_t)thread->fpu_context;
538
539    asm volatile(
540    ".set noreorder           \n"
541    "lwc1    $f0,    0*4(%0)  \n"   
542    "lwc1    $f1,    1*4(%0)  \n"   
543    "lwc1    $f2,    2*4(%0)  \n"   
544    "lwc1    $f3,    3*4(%0)  \n"   
545    "lwc1    $f4,    4*4(%0)  \n"   
546    "lwc1    $f5,    5*4(%0)  \n"   
547    "lwc1    $f6,    6*4(%0)  \n"   
548    "lwc1    $f7,    7*4(%0)  \n"   
549    "lwc1    $f8,    8*4(%0)  \n"   
550    "lwc1    $f9,    9*4(%0)  \n"   
551    "lwc1    $f10,  10*4(%0)  \n"   
552    "lwc1    $f11,  11*4(%0)  \n"   
553    "lwc1    $f12,  12*4(%0)  \n"   
554    "lwc1    $f13,  13*4(%0)  \n"   
555    "lwc1    $f14,  14*4(%0)  \n"   
556    "lwc1    $f15,  15*4(%0)  \n"   
557    "lwc1    $f16,  16*4(%0)  \n"   
558    "lwc1    $f17,  17*4(%0)  \n"   
559    "lwc1    $f18,  18*4(%0)  \n"   
560    "lwc1    $f19,  19*4(%0)  \n"   
561    "lwc1    $f20,  20*4(%0)  \n"   
562    "lwc1    $f21,  21*4(%0)  \n"   
563    "lwc1    $f22,  22*4(%0)  \n"   
564    "lwc1    $f23,  23*4(%0)  \n"   
565    "lwc1    $f24,  24*4(%0)  \n"   
566    "lwc1    $f25,  25*4(%0)  \n"   
567    "lwc1    $f26,  26*4(%0)  \n"   
568    "lwc1    $f27,  27*4(%0)  \n"   
569    "lwc1    $f28,  28*4(%0)  \n"   
570    "lwc1    $f29,  29*4(%0)  \n"   
571    "lwc1    $f30,  30*4(%0)  \n"   
572    "lwc1    $f31,  31*4(%0)  \n"   
573    ".set reorder             \n"
574    : : "r"(ctx) );
575
576} // end hal_cpu_context_restore()
577
578
Note: See TracBrowser for help on using the repository browser.