Changeset 523 for soft/giet_vm


Ignore:
Timestamp:
Mar 10, 2015, 3:21:01 PM (10 years ago)
Author:
alain
Message:

The access functions to the mapping have been modified
to comply with the removing of the coproc and cp_port objects
in the mapping_info.h file.

Location:
soft/giet_vm/giet_common
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_common/kernel_locks.h

    r495 r523  
    1 ///////////////////////////////////////////////////////////////////////////////////
     1//////////////////////////////////////////////////////////////////////////////
    22// File     : kernel_locks.h
    33// Date     : 01/12/2014
    44// Author   : alain greiner
    55// Copyright (c) UPMC-LIP6
    6 ///////////////////////////////////////////////////////////////////////////////////
     6//////////////////////////////////////////////////////////////////////////////
    77// The locks.c and locks.h files are part of the GIET-VM nano-kernel.
    88// They define both atomic increment operations and three types of locks.
    9 ///////////////////////////////////////////////////////////////////////////////////
     9//////////////////////////////////////////////////////////////////////////////
    1010
    1111#ifndef GIET_LOCKS_H
    … …  
    1414#include "hard_config.h"
    1515
    16 ///////////////////////////////////////////////////////////////////////////////////
     16//////////////////////////////////////////////////////////////////////////////
    1717//      Simple lock structure and access functions
    18 ///////////////////////////////////////////////////////////////////////////////////
     18//////////////////////////////////////////////////////////////////////////////
    1919
    2020typedef struct simple_lock_s
    … …  
    2828extern void _simple_lock_release( simple_lock_t* lock );
    2929
    30 ///////////////////////////////////////////////////////////////////////////////////
     30//////////////////////////////////////////////////////////////////////////////
    3131//      Queuing lock structure and access functions
    32 ///////////////////////////////////////////////////////////////////////////////////
     32//////////////////////////////////////////////////////////////////////////////
    3333
    3434typedef struct spin_lock_s
    … …  
    4949
    5050
    51 //////////////////////////////////////////////////////////////////////////////////
     51/////////////////////////////////////////////////////////////////////////////
    5252//      SQT lock structures and access functions
    53 //////////////////////////////////////////////////////////////////////////////////
     53/////////////////////////////////////////////////////////////////////////////
    5454
    5555typedef struct sqt_lock_node_s

  • soft/giet_vm/giet_common/utils.c

    r514 r523  
    1 ///////////////////////////////////////////////////////////////////////////////////
     1///////////////////////////////////////////////////////////////////////////
    22// File     : utils.c
    33// Date     : 18/10/2013
    44// Author   : alain greiner
    55// Copyright (c) UPMC-LIP6
    6 ///////////////////////////////////////////////////////////////////////////////////
     6///////////////////////////////////////////////////////////////////////////
    77// The utils.c and utils.h files are part of the GIET-VM nano-kernel.
    8 ///////////////////////////////////////////////////////////////////////////////////
     8///////////////////////////////////////////////////////////////////////////
    99
    1010#include <utils.h>
    … …  
    1616#include <ctx_handler.h>
    1717
    18 // This global variable is allocated in the boot.c file or in kernel_init.c file
     18// This variable is allocated in the boot.c file or in kernel_init.c file
    1919extern static_scheduler_t* _schedulers[X_SIZE][Y_SIZE][NB_PROCS_MAX];
    2020
    21 ///////////////////////////////////////////////////////////////////////////////////
     21///////////////////////////////////////////////////////////////////////////
    2222//         CP0 registers access functions
    23 ///////////////////////////////////////////////////////////////////////////////////
     23///////////////////////////////////////////////////////////////////////////
    2424
    2525/////////////////////////
    … …  
    119119
    120120
    121 ///////////////////////////////////////////////////////////////////////////////////
     121///////////////////////////////////////////////////////////////////////////
    122122//         CP2 registers access functions
    123 ///////////////////////////////////////////////////////////////////////////////////
     123///////////////////////////////////////////////////////////////////////////
    124124
    125125////////////////////////////
    … …  
    165165
    166166
    167 ////////////////////////////////////////////////////////////////////////////
     167///////////////////////////////////////////////////////////////////////////
    168168//          Physical addressing related functions
    169 ////////////////////////////////////////////////////////////////////////////
     169///////////////////////////////////////////////////////////////////////////
    170170
    171171///////////////////////////////////////////////////////
    … …  
    179179    _it_disable(&sr);
    180180
    181     asm volatile( "mfc2   $2,     $1                 \n"     /* $2 <= MMU_MODE   */
    182                   "andi   $3,     $2,        0xb     \n"
    183                   "mtc2   $3,     $1                 \n"     /* DTLB off         */   
    184 
    185                   "mtc2   %2,     $24                \n"     /* PADDR_EXT <= msb */   
    186                   "lw     %0,     0(%1)              \n"     /* value <= *paddr  */
    187                   "mtc2   $0,     $24                \n"     /* PADDR_EXT <= 0   */   
    188 
    189                   "mtc2   $2,     $1                 \n"     /* restore MMU_MODE */
     181    asm volatile( "mfc2   $2,     $1            \n"  /* $2 <= MMU_MODE   */
     182                  "andi   $3,     $2,     0xb   \n"
     183                  "mtc2   $3,     $1            \n"  /* DTLB off         */   
     184
     185                  "mtc2   %2,     $24           \n"  /* PADDR_EXT <= msb */   
     186                  "lw     %0,     0(%1)         \n"  /* value <= *paddr  */
     187                  "mtc2   $0,     $24           \n"  /* PADDR_EXT <= 0   */   
     188
     189                  "mtc2   $2,     $1            \n"  /* restore MMU_MODE */
    190190                  : "=r" (value)
    191191                  : "r" (lsb), "r" (msb)
    … …  
    205205   _it_disable(&sr);
    206206
    207     asm volatile( "mfc2   $2,     $1                 \n"     /* $2 <= MMU_MODE   */
    208                   "andi   $3,     $2,        0xb     \n"
    209                   "mtc2   $3,     $1                 \n"     /* DTLB off         */   
    210 
    211                   "mtc2   %2,     $24                \n"     /* PADDR_EXT <= msb */   
    212                   "sw     %0,     0(%1)              \n"     /* *paddr <= value  */
    213                   "mtc2   $0,     $24                \n"     /* PADDR_EXT <= 0   */   
    214 
    215                   "mtc2   $2,     $1                 \n"     /* restore MMU_MODE */
    216                   "sync                              \n"
     207    asm volatile( "mfc2   $2,     $1           \n"  /* $2 <= MMU_MODE   */
     208                  "andi   $3,     $2,    0xb   \n"
     209                  "mtc2   $3,     $1           \n"  /* DTLB off         */   
     210
     211                  "mtc2   %2,     $24          \n"  /* PADDR_EXT <= msb */   
     212                  "sw     %0,     0(%1)        \n"  /* *paddr <= value  */
     213                  "mtc2   $0,     $24          \n"  /* PADDR_EXT <= 0   */   
     214
     215                  "mtc2   $2,     $1           \n"  /* restore MMU_MODE */
     216                  "sync                        \n"
    217217                  :
    218218                  : "r" (value), "r" (lsb), "r" (msb)
    … …  
    233233    _it_disable(&sr);
    234234
    235     asm volatile( "mfc2   $2,     $1                 \n"     /* $2 <= MMU_MODE       */
    236                   "andi   $3,     $2,        0xb     \n"
    237                   "mtc2   $3,     $1                 \n"     /* DTLB off             */   
    238 
    239                   "mtc2   %3,     $24                \n"     /* PADDR_EXT <= msb     */   
    240                   "lw     %0,     0(%2)              \n"     /* data_lsb <= *paddr   */
    241                   "lw     %1,     4(%2)              \n"     /* data_msb <= *paddr+4 */
    242                   "mtc2   $0,     $24                \n"     /* PADDR_EXT <= 0       */   
    243 
    244                   "mtc2   $2,     $1                 \n"     /* restore MMU_MODE     */
     235    asm volatile( "mfc2   $2,     $1           \n"  /* $2 <= MMU_MODE       */
     236                  "andi   $3,     $2,    0xb   \n"
     237                  "mtc2   $3,     $1           \n"  /* DTLB off             */   
     238
     239                  "mtc2   %3,     $24          \n"  /* PADDR_EXT <= msb     */   
     240                  "lw     %0,     0(%2)        \n"  /* data_lsb <= *paddr   */
     241                  "lw     %1,     4(%2)        \n"  /* data_msb <= *paddr+4 */
     242                  "mtc2   $0,     $24          \n"  /* PADDR_EXT <= 0       */   
     243
     244                  "mtc2   $2,     $1           \n"  /* restore MMU_MODE     */
    245245                  : "=r" (data_lsb), "=r"(data_msb)
    246246                  : "r" (addr_lsb), "r" (addr_msb)
    … …  
    265265    _it_disable(&sr);
    266266
    267     asm volatile( "mfc2   $2,     $1                 \n"     /* $2 <= MMU_MODE     */
    268                   "andi   $3,     $2,        0xb     \n"
    269                   "mtc2   $3,     $1                 \n"     /* DTLB off           */   
    270 
    271                   "mtc2   %3,     $24                \n"     /* PADDR_EXT <= msb   */   
    272                   "sw     %0,     0(%2)              \n"     /* *paddr <= value    */
    273                   "sw     %1,     4(%2)              \n"     /* *paddr+4 <= value  */
    274                   "mtc2   $0,     $24                \n"     /* PADDR_EXT <= 0     */   
    275 
    276                   "mtc2   $2,     $1                 \n"     /* restore MMU_MODE   */
    277                   "sync                              \n"
     267    asm volatile( "mfc2   $2,     $1           \n"  /* $2 <= MMU_MODE     */
     268                  "andi   $3,     $2,    0xb   \n"
     269                  "mtc2   $3,     $1           \n"  /* DTLB off           */   
     270
     271                  "mtc2   %3,     $24          \n"  /* PADDR_EXT <= msb   */   
     272                  "sw     %0,     0(%2)        \n"  /* *paddr <= value    */
     273                  "sw     %1,     4(%2)        \n"  /* *paddr+4 <= value  */
     274                  "mtc2   $0,     $24          \n"  /* PADDR_EXT <= 0     */   
     275
     276                  "mtc2   $2,     $1           \n"  /* restore MMU_MODE   */
     277                  "sync                        \n"
    278278                  :
    279                   : "r" (data_lsb), "r" (data_msb), "r" (addr_lsb), "r" (addr_msb)
     279                  : "r"(data_lsb),"r"(data_msb),"r"(addr_lsb),"r"(addr_msb)
    280280                  : "$2", "$3" );
    281281
    … …  
    284284
    285285////////////////////////////////////////////////////
    286 void _physical_memcpy( unsigned long long dst_paddr,  // destination buffer paddr
     286void _physical_memcpy( unsigned long long dst_paddr,  // dest buffer paddr
    287287                       unsigned long long src_paddr,  // source buffer paddr
    288288                       unsigned int size )            // bytes
    … …  
    305305    _it_disable(&sr);
    306306
    307     asm volatile( "mfc2   $2,     $1                 \n"    /* $2 <= current MMU_MODE */
    308                   "andi   $3,     $2,        0xb     \n"    /* $3 <= new MMU_MODE     */
    309                   "mtc2   $3,     $1                 \n"    /* DTLB off               */   
    310 
    311                   "move   $4,     %5                 \n"    /* $4 < iter              */
    312                   "move   $5,     %1                 \n"    /* $5 < src_lsb           */
    313                   "move   $6,     %3                 \n"    /* $6 < src_lsb           */
    314 
    315                   "ph_memcpy_loop:                   \n"
    316                   "mtc2   %2,     $24                \n"    /* PADDR_EXT <= src_msb   */   
    317                   "lw     %0,     0($5)              \n"    /* data <= *src_paddr     */
    318                   "mtc2   %4,     $24                \n"    /* PADDR_EXT <= dst_msb   */   
    319                   "sw     %0,     0($6)              \n"    /* *dst_paddr <= data     */
    320 
    321                   "addi   $4,     $4,       -1       \n"    /* iter = iter - 1        */
    322                   "addi   $5,     $5,        4       \n"    /* src_lsb += 4           */
    323                   "addi   $6,     $6,        4       \n"    /* dst_lsb += 4           */
     307    asm volatile( "mfc2   $2,     $1         \n" /* $2 <= current MMU_MODE */
     308                  "andi   $3,     $2,   0xb  \n" /* $3 <= new MMU_MODE     */
     309                  "mtc2   $3,     $1         \n" /* DTLB off               */   
     310
     311                  "move   $4,     %5         \n" /* $4 < iter              */
     312                  "move   $5,     %1         \n" /* $5 < src_lsb           */
     313                  "move   $6,     %3         \n" /* $6 < src_lsb           */
     314
     315                  "ph_memcpy_loop:           \n"
     316                  "mtc2   %2,     $24        \n" /* PADDR_EXT <= src_msb   */   
     317                  "lw     %0,     0($5)      \n" /* data <= *src_paddr     */
     318                  "mtc2   %4,     $24        \n" /* PADDR_EXT <= dst_msb   */   
     319                  "sw     %0,     0($6)      \n" /* *dst_paddr <= data     */
     320
     321                  "addi   $4,     $4,   -1   \n" /* iter = iter - 1        */
     322                  "addi   $5,     $5,   4    \n" /* src_lsb += 4           */
     323                  "addi   $6,     $6,   4    \n" /* dst_lsb += 4           */
    324324                  "bne    $4,     $0, ph_memcpy_loop \n"
    325                   "nop                               \n"
    326 
    327                   "mtc2   $0,     $24                \n"    /* PADDR_EXT <= 0         */   
    328                   "mtc2   $2,     $1                 \n"    /* restore MMU_MODE       */
     325                  "nop                       \n"
     326
     327                  "mtc2   $0,     $24        \n" /* PADDR_EXT <= 0         */   
     328                  "mtc2   $2,     $1         \n" /* restore MMU_MODE       */
    329329                  : "=r" (data)
    330                   : "r" (src_lsb), "r" (src_msb), "r" (dst_lsb), "r"(dst_msb), "r"(iter)
     330                  : "r"(src_lsb),"r"(src_msb),"r"(dst_lsb),
     331                    "r"(dst_msb), "r"(iter)
    331332                  : "$2", "$3", "$4", "$5", "$6" );
    332333
    … …  
    335336
    336337////////////////////////////////////////////////
    337 void _physical_memset( unsigned long long paddr,     // destination buffer paddr
     338void _physical_memset( unsigned long long paddr,     // dest buffer paddr
    338339                       unsigned int       size,      // bytes
    339340                       unsigned int       data )     // written value
    … …  
    352353    _it_disable(&sr);
    353354
    354     asm volatile( "mfc2   $8,     $1                 \n"    /* $8 <= current MMU_MODE */
    355                   "andi   $9,     $8,        0xb     \n"    /* $9 <= new MMU_MODE     */
    356                   "mtc2   $9,     $1                 \n"    /* DTLB off               */
    357                   "mtc2   %3,     $24                \n"    /* PADDR_EXT <= msb       */
    358 
    359                   "1:                                \n"    /* set 8 bytes per iter   */
    360                   "sw     %2,     0(%0)              \n"    /* *src_paddr     = data  */
    361                   "sw     %2,     4(%0)              \n"    /* *(src_paddr+4) = data  */
    362                   "addi   %1,     %1,       -8       \n"    /* size -= 8              */
    363                   "addi   %0,     %0,        8       \n"    /* src_paddr += 8         */
    364                   "bnez   %1,     1b                 \n"    /* loop while size != 0   */
    365 
    366                   "mtc2   $0,     $24                \n"    /* PADDR_EXT <= 0         */
    367                   "mtc2   $8,     $1                 \n"    /* restore MMU_MODE       */
     355    asm volatile( "mfc2   $8,     $1         \n" /* $8 <= current MMU_MODE */
     356                  "andi   $9,     $8,   0xb  \n" /* $9 <= new MMU_MODE     */
     357                  "mtc2   $9,     $1         \n" /* DTLB off               */
     358                  "mtc2   %3,     $24        \n" /* PADDR_EXT <= msb       */
     359
     360                  "1:                        \n" /* set 8 bytes per iter   */
     361                  "sw     %2,     0(%0)      \n" /* *src_paddr     = data  */
     362                  "sw     %2,     4(%0)      \n" /* *(src_paddr+4) = data  */
     363                  "addi   %1,     %1,   -8   \n" /* size -= 8              */
     364                  "addi   %0,     %0,    8   \n" /* src_paddr += 8         */
     365                  "bnez   %1,     1b         \n" /* loop while size != 0   */
     366
     367                  "mtc2   $0,     $24        \n" /* PADDR_EXT <= 0         */
     368                  "mtc2   $8,     $1         \n" /* restore MMU_MODE       */
    368369                  : "+r"(lsb), "+r"(size)
    369370                  : "r"(data), "r" (msb)
    … …  
    409410}
    410411
    411 ///////////////////////////////////////////////////////////////////////////////////
    412 //                      barrier functions
    413 ///////////////////////////////////////////////////////////////////////////////////
    414 void _barrier_init( _giet_barrier_t* barrier,
    415                    unsigned int    ntasks )
    416 {
    417     barrier->ntasks = ntasks;
    418     barrier->count  = ntasks;
    419     barrier->sense  = 0;
    420 
    421     asm volatile ("sync" ::: "memory");
    422 }
    423 
    424 ////////////////////////////////////////////
    425 void _barrier_wait( _giet_barrier_t* barrier )
    426 {
    427 
    428     // compute expected sense value
    429     unsigned int expected;
    430     if ( barrier->sense == 0 ) expected = 1;
    431     else                       expected = 0;
    432 
    433     // parallel decrement barrier counter using atomic instructions LL/SC
    434     // - input : pointer on the barrier counter (pcount)
    435     // - output : counter value (count)
    436     volatile unsigned int* pcount  = (unsigned int *)&barrier->count;
    437     volatile unsigned int  count    = 0;  // avoid a warning
    438 
    439     asm volatile( "addu   $2,     %1,        $0      \n"
    440                   "barrier_llsc:                     \n"
    441                   "ll     $8,     0($2)              \n"
    442                   "addi   $9,     $8,        -1      \n"
    443                   "sc     $9,     0($2)              \n"
    444                   "beqz   $9,     barrier_llsc       \n"
    445                   "addu   %0,     $8,        $0      \n"
    446                   : "=r" (count)
    447                   : "r" (pcount)
    448                   : "$2", "$8", "$9", "memory" );
    449 
    450     // the last task re-initializes count and toggle sense,
    451     // waking up all other waiting tasks
    452     if (count == 1)   // last task
    453     {
    454         barrier->count = barrier->ntasks;
    455         barrier->sense = expected;
    456     }
    457     else              // other tasks busy waiting the sense flag
    458     {
    459         // polling sense flag
    460         // input: pointer on the sens flag (psense)
    461         // input: expected sense value (expected)
    462         volatile unsigned int* psense  = (unsigned int *)&barrier->sense;
    463         asm volatile ( "barrier_sense:                   \n"
    464                        "lw    $3,   0(%0)                \n"
    465                        "bne   $3,   %1,    barrier_sense \n"
    466                        :
    467                        : "r"(psense), "r"(expected)
    468                        : "$3" );
    469     }
    470 
    471     asm volatile ("sync" ::: "memory");
    472 }
    473 
    474 ///////////////////////////////////////////////////////////////////////////////////
    475 //                      Locks access functions
    476 ///////////////////////////////////////////////////////////////////////////////////
    477 
    478 ///////////////////////////////////
    479 void _get_lock( _giet_lock_t* lock )
    480 {
    481     unsigned int* plock = (unsigned int*)&(lock->value);
    482 
    483 #if NO_HARD_CC
    484 
    485     register unsigned int delay  = (_get_proctime() ^ _get_procid() << 4) & 0xFF;
    486     if (delay == 0) delay = 0x80;
    487 
    488     asm volatile (
    489             "_lock_llsc:             \n"
    490             "    ll   $2,    0(%0)       \n" /* $2 <= lock current value         */
    491             "    bnez $2,    _lock_delay \n" /* delay if lock already taken      */
    492             "    li   $3,    1           \n" /* $3 <= argument for sc            */
    493             "    sc   $3,    0(%0)       \n" /* try to set lock                  */
    494             "    bnez $3,    _lock_ok    \n" /* exit if atomic                   */
    495             "    _lock_delay:            \n"
    496             "    move $4,    %1          \n" /* $4 <= delay                      */
    497             "    _lock_loop:             \n"
    498             "    addi $4,    $4,    -1   \n" /* $4 <= $4 - 1                     */
    499             "    bnez $4,    _lock_loop  \n" /* test end delay                   */
    500             "    nop                     \n"
    501             "    j           _lock_llsc  \n" /* retry                            */
    502             "    nop                     \n"
    503             "    _lock_ok:               \n"
    504             :
    505             :"r"(plock), "r"(delay)
    506             :"$2", "$3", "$4", "memory");
    507 #else
    508 
    509     asm volatile (
    510             "_lock_llsc:                 \n"
    511             "    lw   $2,    0(%0)       \n" /* $2 <= lock current value         */
    512             "    bnez $2,    _lock_llsc  \n" /* retry if lock already taken      */
    513             "    nop                     \n"
    514             "    ll   $2,    0(%0)       \n" /* ll_buffer <= lock current value  */
    515             "    bnez $2,    _lock_llsc  \n" /* retry if lock already taken      */
    516             "    li   $3,    1           \n" /* $3 <= argument for sc            */
    517             "    sc   $3,    0(%0)       \n" /* try to set lock                  */
    518             "    beqz $3,    _lock_llsc  \n" /* retry if sc failure              */
    519             "    nop                     \n"
    520             :
    521             :"r"(plock)
    522             :"$2", "$3", "memory");
    523 #endif
    524 
    525 }
    526 
    527 ///////////////////////////////////////
    528 void _release_lock( _giet_lock_t* lock )
    529 {
    530     asm volatile ( "sync\n" ::: "memory" );
    531     // sync is necessary because of the TSAR consistency model
    532     lock->value = 0;
    533 }
    534 
    535 ////////////////////////////////////////////////////////////////////////////////////
     412////////////////////////////////////////////////////////////////////////////
    536413//           Scheduler and tasks context access functions
    537 ////////////////////////////////////////////////////////////////////////////////////
     414////////////////////////////////////////////////////////////////////////////
    538415
    539416
    … …  
    652529            MAPPING_PROC_SIZE * header->procs);
    653530}
    654 /////////////////////////////////////////////////////////////
    655 mapping_coproc_t *_get_coproc_base(mapping_header_t * header)
    656 {
    657     return (mapping_coproc_t *) ((char *) header +
     531///////////////////////////////////////////////////////////////
     532mapping_periph_t *_get_periph_base(mapping_header_t * header)
     533{
     534    return (mapping_periph_t *) ((char *) header +
    658535            MAPPING_HEADER_SIZE +
    659536            MAPPING_CLUSTER_SIZE * X_SIZE * Y_SIZE +
    … …  
    665542            MAPPING_IRQ_SIZE * header->irqs);
    666543}
    667 ///////////////////////////////////////////////////////////////
    668 mapping_cp_port_t *_get_cp_port_base(mapping_header_t * header)
    669 {
    670     return (mapping_cp_port_t *) ((char *) header +
    671             MAPPING_HEADER_SIZE +
    672             MAPPING_CLUSTER_SIZE * X_SIZE * Y_SIZE +
    673             MAPPING_PSEG_SIZE * header->psegs +
    674             MAPPING_VSPACE_SIZE * header->vspaces +
    675             MAPPING_VSEG_SIZE * header->vsegs +
    676             MAPPING_TASK_SIZE * header->tasks +
    677             MAPPING_PROC_SIZE * header->procs +
    678             MAPPING_IRQ_SIZE * header->irqs +
    679             MAPPING_COPROC_SIZE * header->coprocs);
    680 }
    681 /////////////////////////////////////////////////////////////
    682 mapping_periph_t *_get_periph_base(mapping_header_t * header)
    683 {
    684     return (mapping_periph_t *) ((char *) header +
    685             MAPPING_HEADER_SIZE +
    686             MAPPING_CLUSTER_SIZE * X_SIZE * Y_SIZE +
    687             MAPPING_PSEG_SIZE * header->psegs +
    688             MAPPING_VSPACE_SIZE * header->vspaces +
    689             MAPPING_VSEG_SIZE * header->vsegs +
    690             MAPPING_TASK_SIZE * header->tasks +
    691             MAPPING_PROC_SIZE * header->procs +
    692             MAPPING_IRQ_SIZE * header->irqs +
    693             MAPPING_COPROC_SIZE * header->coprocs +
    694             MAPPING_CP_PORT_SIZE * header->cp_ports);
    695 }
    696 
    697 ///////////////////////////////////////////////////////////////////////////////////
     544
     545///////////////////////////////////////////////////////////////////////////
    698546//             Miscelaneous functions
    699 ///////////////////////////////////////////////////////////////////////////////////
     547///////////////////////////////////////////////////////////////////////////
    700548
    701549//////////////////////////////////////
    702550__attribute__((noreturn)) void _exit()
    703551{
    704     unsigned int procid     = _get_procid();
    705     unsigned int x          = (procid >> (Y_WIDTH + P_WIDTH)) & ((1<<X_WIDTH)-1);
    706     unsigned int y          = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
    707     unsigned int lpid       = procid & ((1<<P_WIDTH)-1);
     552    unsigned int procid = _get_procid();
     553    unsigned int x      = (procid >> (Y_WIDTH + P_WIDTH)) & ((1<<X_WIDTH)-1);
     554    unsigned int y      = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
     555    unsigned int lpid   = procid & ((1<<P_WIDTH)-1);
    708556
    709557
    … …  
    835683
    836684
    837 ///////////////////////////////////////////////////////////////////////////////////
     685///////////////////////////////////////////////////////////////////////////
    838686//   Required by GCC
    839 ///////////////////////////////////////////////////////////////////////////////////
     687///////////////////////////////////////////////////////////////////////////
    840688
    841689////////////////////////////////

  • soft/giet_vm/giet_common/utils.h

    r514 r523  
    3737
    3838
    39 ///////////////////////////////////////////////////////////////////////////////////
    40 //      Locks access functions
    41 ///////////////////////////////////////////////////////////////////////////////////
    42 volatile typedef struct _giet_barrier_s
    43 {
    44     char         name[32];   // barrier name
    45     unsigned int sense;      // barrier state (toggle)
    46     unsigned int ntasks;     // total number of expected tasks
    47     unsigned int count;      // number of not arrived tasks
    48 } _giet_barrier_t;
    49 
    50 extern void _barrier_init( _giet_barrier_t* barrier,
    51                            unsigned int    ntasks );   
    52 
    53 extern void _barrier_wait( _giet_barrier_t* barrier );
    54 
    55 
    56 ///////////////////////////////////////////////////////////////////////////////////
    57 //      Locks access functions
    58 ///////////////////////////////////////////////////////////////////////////////////
    59 volatile typedef struct _giet_lock_s { unsigned int value;
    60                                        unsigned int padding[15]; } _giet_lock_t;
    61 
    62 
    63 extern void _get_lock(_giet_lock_t* lock);
    64 
    65 extern void _release_lock(_giet_lock_t* lock);
    66 ///////////////////////////////////////////////////////////////////////////////////
     39///////////////////////////////////////////////////////////////////////////
    6740//     CP0 registers access functions
    68 ///////////////////////////////////////////////////////////////////////////////////
     41///////////////////////////////////////////////////////////////////////////
    6942
    7043extern unsigned int _get_sched(void);
    … …  
    9063extern void         _set_sr(unsigned int value);
    9164
    92 ///////////////////////////////////////////////////////////////////////////////////
     65///////////////////////////////////////////////////////////////////////////
    9366//     CP2 registers access functions
    94 ///////////////////////////////////////////////////////////////////////////////////
     67///////////////////////////////////////////////////////////////////////////
    9568
    9669extern unsigned int _get_mmu_ptpr(void);
    … …  
    10477extern void         _set_mmu_dcache_inval(unsigned int value);
    10578
    106 ///////////////////////////////////////////////////////////////////////////////////
     79///////////////////////////////////////////////////////////////////////////
    10780//     Physical addressing functions
    108 ///////////////////////////////////////////////////////////////////////////////////
     81///////////////////////////////////////////////////////////////////////////
    10982
    11083extern unsigned int _physical_read(  unsigned long long paddr );
    … …  
    131104                                        unsigned int  value );
    132105
    133 ///////////////////////////////////////////////////////////////////////////////////
     106///////////////////////////////////////////////////////////////////////////
    134107//       Scheduler and task context access functions
    135 ///////////////////////////////////////////////////////////////////////////////////
     108///////////////////////////////////////////////////////////////////////////
    136109
    137110extern unsigned int _get_current_task_id(void);
    … …  
    155128                                       unsigned int value );
    156129
    157 ///////////////////////////////////////////////////////////////////////////////////
     130///////////////////////////////////////////////////////////////////////////
    158131//     Mapping access functions
    159 ///////////////////////////////////////////////////////////////////////////////////
     132///////////////////////////////////////////////////////////////////////////
    160133
    161134extern mapping_cluster_t *  _get_cluster_base(mapping_header_t* header);
    … …  
    166139extern mapping_proc_t *     _get_proc_base(mapping_header_t* header);
    167140extern mapping_irq_t *      _get_irq_base(mapping_header_t* header);
    168 extern mapping_coproc_t *   _get_coproc_base(mapping_header_t* header);
    169 extern mapping_cp_port_t *  _get_cp_port_base(mapping_header_t* header);
    170141extern mapping_periph_t *   _get_periph_base(mapping_header_t* header);
    171142
    172 ///////////////////////////////////////////////////////////////////////////////////
     143///////////////////////////////////////////////////////////////////////////
    173144//     Miscelaneous functions
    174 ///////////////////////////////////////////////////////////////////////////////////
     145///////////////////////////////////////////////////////////////////////////
    175146
    176147extern void         _exit(void);
    … …  
    194165                                        unsigned int* levels );
    195166
    196 ///////////////////////////////////////////////////////////////////////////////////
     167//////////////////////////////////////////////////////////////////////////
    197168//     Required by GCC
    198 ///////////////////////////////////////////////////////////////////////////////////
     169//////////////////////////////////////////////////////////////////////////
    199170
    200 ///////////////////////////////////////////////////////////////////////////////////
    201171extern void* memcpy( void*        dst,
    202172                     const void*  src,
Note: See TracChangeset for help on using the changeset viewer.