Ignore:
Timestamp:
Aug 7, 2012, 6:37:49 PM (12 years ago)
Author:
alain
Message:

Introducing a new release where all initialisation
is done in the boot code.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/sys/common.c

    r166 r189  
    1111#include <sys_handler.h>
    1212#include <common.h>
     13#include <ctx_handler.h>
    1314#include <drivers.h>
    1415#include <stdarg.h>
    1516
    16 ////////////////////////////////////////////////////////////////////////////
    17 // _get_lock()
     17///////////////////////////////////////////////////////////////////////////////////
     18//      Global variables
     19///////////////////////////////////////////////////////////////////////////////////
     20
     21// current context cache TODO
     22
     23// SR save (used by _it_mask() / it_restore()
     24unsigned int    _status_register_save;
     25
     26///////////////////////////////////////////////////////////////////////////////////
     27//        _get_sched()
     28// Access CP0 and returns scheduler physical address.
     29///////////////////////////////////////////////////////////////////////////////////
     30inline unsigned int _get_sched()
     31{
     32    unsigned int ret;
     33    asm volatile (      "mfc0   %0,             $22"
     34                                        : "=r"(ret) );
     35    return ret;
     36}
     37///////////////////////////////////////////////////////////////////////////////////
     38//        _get_ptpr()
     39// Access CP2 and returns PTPR register.
     40///////////////////////////////////////////////////////////////////////////////////
     41inline unsigned int _get_ptpr()
     42{
     43    unsigned int ret;
     44    asm volatile (      "mfc2   %0,             $0"
     45                                        : "=r"(ret) );
     46    return ret;
     47}
     48///////////////////////////////////////////////////////////////////////////////////
     49//        _get_epc()
     50// Access CP0 and returns EPC register.
     51///////////////////////////////////////////////////////////////////////////////////
     52inline unsigned int _get_epc()
     53{
     54    unsigned int ret;
     55    asm volatile (      "mfc0   %0,             $14"
     56                                        : "=r"(ret) );
     57    return ret;
     58}
     59///////////////////////////////////////////////////////////////////////////////////
     60//        _get_bar()
     61// Access CP0 and returns BAR register.
     62///////////////////////////////////////////////////////////////////////////////////
     63inline unsigned int _get_bvar()
     64{
     65    unsigned int ret;
     66    asm volatile (      "mfc0   %0,             $8"
     67                                        : "=r"(ret) );
     68    return ret;
     69}
     70///////////////////////////////////////////////////////////////////////////////////
     71//        _get_cr()
     72// Access CP0 and returns CR register.
     73///////////////////////////////////////////////////////////////////////////////////
     74inline unsigned int _get_cause()
     75{
     76    unsigned int ret;
     77    asm volatile (      "mfc0   %0,             $13"
     78                                        : "=r"(ret) );
     79    return ret;
     80}
     81///////////////////////////////////////////////////////////////////////////////////
     82//        _get_sr()
     83// Access CP0 and returns SR register.
     84///////////////////////////////////////////////////////////////////////////////////
     85inline unsigned int _get_sr()
     86{
     87    unsigned int ret;
     88    asm volatile (      "mfc0   %0,             $12"
     89                                        : "=r"(ret) );
     90    return ret;
     91}
     92///////////////////////////////////////////////////////////////////////////////////
     93//    _it_mask()
     94// Access CP0 and mask IRQs
     95///////////////////////////////////////////////////////////////////////////////////
     96inline void _it_mask()
     97{
     98    unsigned int        sr_value;
     99    asm volatile(       "li             $3,             0xFFFFFFFE      \n"
     100                                        "mfc0   %0,             $12                     \n"
     101                                        "and    $3,             $3, %0          \n"
     102                                        "mtc0   $3,             $12                     \n"
     103                                        : "=r"(sr_value) : : "$3" );
     104    _status_register_save = sr_value;
     105}
     106///////////////////////////////////////////////////////////////////////////////////
     107//    _it_enable()
     108// Access CP0 and enable IRQs
     109///////////////////////////////////////////////////////////////////////////////////
     110inline void _it_restore()
     111{
     112    unsigned int        sr_value = _status_register_save;
     113    asm volatile(       "mtc0  %0,              $12                     \n"
     114                                        : : "r"(sr_value) );
     115}
     116////////////////////////////////////////////////////////////////////////////
     117//    _get_lock()
     118// Takes a lock with an ll/sc atomic access.
     119// A pseudo random delay is introduced before retry in case of miss
     120// (delay average value = 100 cycles)
    18121////////////////////////////////////////////////////////////////////////////
    19122inline void _get_lock( unsigned int* plock )
    20123{
    21     register unsigned int  delay = (_proctime() & 0xF) << 4;
     124    register unsigned int  delay = ( _proctime() ^ _procid()<<4 ) & 0xFF;
    22125
    23126    asm volatile (
    … …  
    49152
    50153////////////////////////////////////////////////////////////////////////////
    51 // _puts()
    52 // used for system code debug / it uses TTY0
     154//    _puts()
     155// display a string on TTY0 / used for system code debugand log
    53156////////////////////////////////////////////////////////////////////////////
    54157void _puts(char *buffer)
    … …  
    64167}
    65168////////////////////////////////////////////////////////////////////////////
    66 // _putw()
    67 // used for system code debug / it uses TTY0
     169//    _putw()
     170// display an int (hexa) on TTY0 / used for system code debug and log
    68171////////////////////////////////////////////////////////////////////////////
    69172void _putw(unsigned int val)
    … …  
    85188}
    86189////////////////////////////////////////////////////////////////////////////
    87 // _strncmp()
     190//    _putd()
     191// display an int (decimal) on TTY0 / used for system code debug and log
     192////////////////////////////////////////////////////////////////////////////
     193void _putd(unsigned int val)
     194{
     195    static const char   DecTab[] = "0123456789";
     196    char                                buf[11];
     197    unsigned int                i;
     198    unsigned int                first;
     199
     200    buf[10] = 0;
     201
     202    for (i = 0; i < 10; i++)
     203    {
     204        if ((val != 0) || (i == 0))
     205        {
     206            buf[9-i] = DecTab[val % 10];
     207            first    = 9-i;
     208        }
     209        else
     210        {
     211            break;
     212        }
     213        val /= 10;
     214    }
     215    _puts( &buf[first] );
     216}
     217////////////////////////////////////////////////////////////////////////////
     218//    _strncmp()
    88219// compare two strings s1 & s2 (no more than n characters)
    89220////////////////////////////////////////////////////////////////////////////
    … …  
    101232}
    102233////////////////////////////////////////////////////////////////////////////
    103 //      _dcache_buf_invalidate()
     234//         _dcache_buf_invalidate()
    104235// Invalidate all data cache lines corresponding to a memory
    105236// buffer (identified by an address and a size).
    … …  
    126257    }
    127258}
    128 ///////////////////////////////////////////////////////////////////////////////////
    129 //      _itoa_dec()
    130 // Convert a 32-bit unsigned integer to a string of ten decimal characters.
    131 ///////////////////////////////////////////////////////////////////////////////////
    132 void _itoa_dec(unsigned int val, char *buf)
    133 {
    134     const static char dectab[] = "0123456789";
    135     unsigned int i;
    136 
    137     for (i = 0; i < 10; i++)
    138     {
    139         if ((val != 0) || (i == 0))
    140             buf[9-i] = dectab[val % 10];
    141         else
    142             buf[9-i] = 0x20;
    143         val /= 10;
    144     }
    145 }
    146 ///////////////////////////////////////////////////////////////////////////////////
    147 //      _itoa_hex()
    148 // Convert a 32-bit unsigned integer to a string of eight hexadecimal characters.
    149 ///////////////////////////////////////////////////////////////////////////////////
    150 void _itoa_hex(unsigned int val, char *buf)
    151 {
    152     const static char hexatab[] = "0123456789ABCD";
    153     unsigned int i;
    154 
    155     for (i = 0; i < 8; i++)
    156     {
    157         buf[7-i] = hexatab[val % 16];
    158         val /= 16;
    159     }
    160 }
    161 ///////////////////////////////////////////////////////////////////////////////////
    162 //      _get_ptpr()
    163 // Access CP2 and returns PTPR register.
    164 ///////////////////////////////////////////////////////////////////////////////////
    165 inline unsigned int _get_ptpr()
    166 {
    167     unsigned int ret;
    168     asm volatile("mfc2 %0, $0" : "=r"(ret));
    169     return ret;
    170 }
    171 ///////////////////////////////////////////////////////////////////////////////////
    172 //      _get_epc()
    173 // Access CP0 and returns EPC register.
    174 ///////////////////////////////////////////////////////////////////////////////////
    175 inline unsigned int _get_epc()
    176 {
    177     unsigned int ret;
    178     asm volatile("mfc0 %0, $14" : "=r"(ret));
    179     return ret;
    180 }
    181 ///////////////////////////////////////////////////////////////////////////////////
    182 //      _get_bar()
    183 // Access CP0 and returns BAR register.
    184 ///////////////////////////////////////////////////////////////////////////////////
    185 inline unsigned int _get_bar()
    186 {
    187     unsigned int ret;
    188     asm volatile("mfc0 %0, $8" : "=r"(ret));
    189     return ret;
    190 }
    191 ///////////////////////////////////////////////////////////////////////////////////
    192 //      _get_cr()
    193 // Access CP0 and returns CR register.
    194 ///////////////////////////////////////////////////////////////////////////////////
    195 inline unsigned int _get_cause()
    196 {
    197     unsigned int ret;
    198     asm volatile("mfc0 %0, $13" : "=r"(ret));
    199     return ret;
    200 }
    201 
    202 ///////////////////////////////////////////////////////////////////////////////////
    203 //      _it_mask()
    204 // Access CP0 and mask IRQs
    205 ///////////////////////////////////////////////////////////////////////////////////
    206 inline void _it_mask()
    207 {
    208     asm volatile(
    209             "lui   $27,      0xFFFF   \n"
    210             "ori   $27, $27, 0xFFFE   \n"
    211             "mfc0  $26, $12           \n"
    212             "and   $26, $26, $27      \n"
    213             "mtc0  $26, $12           \n"
    214             ::: "$26", "$27"
    215             );
    216 }
    217 ///////////////////////////////////////////////////////////////////////////////////
    218 //      _it_enable()
    219 // Access CP0 and enable IRQs
    220 ///////////////////////////////////////////////////////////////////////////////////
    221 inline void _it_enable()
    222 {
    223     asm volatile(
    224             "mfc0  $26, $12      \n"
    225             "ori   $26, $26, 1   \n"
    226             "mtc0  $26, $12      \n"
    227             ::: "$26"
    228             );
     259////////////////////////////////////////////////////////////////////////////
     260//    _physical_read_access()
     261// This function makes a physical read access to a 32 bits word in memory,
     262// after a temporary DTLB desactivation.
     263////////////////////////////////////////////////////////////////////////////
     264unsigned int _physical_read_access(unsigned int* paddr)
     265{
     266    unsigned int value;
     267
     268    asm volatile(   "li     $3,     0xFFFFFFFE          \n"
     269                    "mfc0   $2,     $12                         \n"             /* $2 <= SR        */
     270                    "and    $3,     $3,         $2              \n"
     271                    "mtc0   $3,     $12                         \n"             /* interrupt masked */
     272                    "li         $3,             0xB                             \n"
     273                    "mtc2       $3,             $1                              \n"             /* DTLB off                     */     
     274
     275                    "lw         %0,             0(%1)                   \n"             /* entry <= *pslot      */
     276
     277                    "li         $3,             0xF                             \n"
     278                    "mtc2       $3,             $1                              \n"             /* DTLB on                      */     
     279                    "mtc0       $2,             $12                             \n"             /* restore SR           */
     280                    : "=r"(value)
     281                    : "r"(paddr)
     282                    : "$2", "$3" );
     283    return value;
     284}
     285////////////////////////////////////////////////////////////////////////////
     286//    _physical_write_access()
     287// This function makes a physical write access to a 32 bits word in memory,
     288// after a temporary DTLB desactivation.
     289////////////////////////////////////////////////////////////////////////////
     290void _physical_write_access(unsigned int* paddr, unsigned int value)
     291{
     292    asm volatile(   "li     $3,     0xFFFFFFFE          \n"
     293                    "mfc0   $2,     $12                         \n"             /* $26 <= SR        */
     294                    "and    $3,     $3,         $2              \n"
     295                    "mtc0   $3,     $12                         \n"             /* interrupt masked */
     296                    "li         $3,             0xB                             \n"
     297                    "mtc2       $3,             $1                              \n"             /* DTLB off                     */
     298       
     299                    "sw         %0,             0(%1)                   \n"             /* entry <= *pslot      */
     300
     301                    "li         $3,             0xF                             \n"
     302                    "mtc2       $3,             $1                              \n"             /* DTLB on                      */     
     303                    "mtc0       $2,             $12                             \n"             /* restore SR           */
     304                    :
     305                    : "r"(value), "r"(paddr)
     306                    : "$2", "$3" );
     307}
     308////////////////////////////////////////////////////////////////////////////
     309//    _get_tasks_number()
     310// This function returns the number of tasks allocated to processor.
     311////////////////////////////////////////////////////////////////////////////
     312unsigned int _get_tasks_number()
     313{
     314    static_scheduler_t*         psched = (static_scheduler_t*)_get_sched();
     315    return _physical_read_access( &(psched->tasks) );
     316}
     317////////////////////////////////////////////////////////////////////////////
     318//    _get_current_task_id()
     319// This function returns the index of the currently running task.
     320////////////////////////////////////////////////////////////////////////////
     321unsigned int _get_current_task_id()
     322{
     323    static_scheduler_t*         psched = (static_scheduler_t*)_get_sched();
     324    return _physical_read_access( &(psched->current) );
     325}
     326///////////////////////////////////////////////////////////////////////////////
     327//    _get_current_context_slot()
     328// This function returns the global TTY index for the currently running task.
     329///////////////////////////////////////////////////////////////////////////////
     330unsigned int _get_current_context_slot(unsigned int slot_id)
     331{
     332    static_scheduler_t*         psched = (static_scheduler_t*)_get_sched();
     333    unsigned int                        current = _physical_read_access( &(psched->current) );
     334    return _physical_read_access( &(psched->context[current][slot_id]) );
     335}
     336/////////////////////////////////////////////i//////////////////////////////////
     337//    _get_interrupt_vector_entry()
     338// This function returns the interrupt_vector entry defined by argument index.
     339////////////////////////////////////////////////////////////////////////////////
     340unsigned int _get_interrupt_vector_entry( unsigned int index )
     341{
     342    static_scheduler_t*         psched = (static_scheduler_t*)_get_sched();
     343    return _physical_read_access( &(psched->interrupt_vector[index]) );
     344}
     345////////////////////////////////////////////////////////////////////////////
     346//    _set_current_task_id()
     347// This function returns the index of the currently running task.
     348////////////////////////////////////////////////////////////////////////////
     349void _set_current_task_id( unsigned int value )
     350{
     351    static_scheduler_t*         psched = (static_scheduler_t*)_get_sched();
     352    _physical_write_access( &(psched->current), value );
    229353}
    230354
    … …  
    283407}
    284408
    285 
Note: See TracChangeset for help on using the changeset viewer.