Changeset 121


Ignore:
Timestamp:
Jul 3, 2017, 2:17:20 PM (4 years ago)
Author:
alain
Message:

Fix bugs in hal_remote, hal uspace, hal_special

Location:
trunk/hal
Files:
3 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/hal/generic/hal_remote.h

    r95 r121  
    174174                        uint32_t size );
    175175
     176/*****************************************************************************************
     177 * This function makes a copy from a source character string to another destination
     178 * character string, including the NUL terminating character.
     179 *****************************************************************************************
     180 * @ dst     : extended pointer to destination char array.
     181 * @ src     : extended pointer to source char array.
     182 ****************************************************************************************/
     183void hal_remote_strcpy( xptr_t dst,
     184                        xptr_t src );
     185
    176186#endif  /* _HAL_REMOTE_H_ */
  • trunk/hal/generic/hal_special.h

    r101 r121  
    4040 * This function returns the global core identifier from the calling core register.
    4141 ****************************************************************************************/
    42 gid_t hal_get_gid();
     42inline gid_t hal_get_gid();
     43
     44/*****************************************************************************************
     45 * This function returns the current value of the hardware cycles counter.
     46 ****************************************************************************************/
     47inline cycle_t hal_time_stamp();
    4348
    4449/*****************************************************************************************
     
    5257 * This function returns the current thread pointer from the calling core register.
    5358 ****************************************************************************************/
    54 struct thread_s * hal_get_current_thread();
     59inline struct thread_s * hal_get_current_thread();
    5560
    5661/*****************************************************************************************
  • trunk/hal/generic/hal_uspace.h

    r95 r121  
    6464 * This function tranfers a NUL terminated string from the user space to the kernel space.
    6565 * If the kernel uses physical addresses, it activates the MMU to access the user buffer.
     66 * TODO : implement the max_size argument handling
    6667 *****************************************************************************************
    6768 * @ u_dst     : destination buffer address in user space.
    6869 * @ k_src     : source address in kernel space.
     70 * @ max_size  : max number of characters to be copied.
    6971 ****************************************************************************************/
    70 extern void hal_strcpy_from_uspace( char * k_dst,
    71                                     char * u_src );
     72extern void hal_strcpy_from_uspace( char     * k_dst,
     73                                    char     * u_src,
     74                                    uint32_t   max_size );
    7275
    7376/*****************************************************************************************
    7477 * This function tranfers a NUL terminated string from the kernel space to the user space.
    7578 * If the kernel uses physical addresses, it activates the MMU to access the user buffer.
     79 * TODO : implement the max_size argument handling
    7680 *****************************************************************************************
    7781 * @ u_dst     : destination buffer address in user space.
    7882 * @ k_src     : source address in kernel space.
     83 * @ max_size  : max number of characters to be copied.
    7984 ****************************************************************************************/
    80 extern void hal_strcpy_to_uspace( char * u_dst,
    81                                   char * k_src );
     85extern void hal_strcpy_to_uspace( char     * u_dst,
     86                                  char     * k_src,
     87                                  uint32_t   max_size );
    8288
    8389/*****************************************************************************************
  • trunk/hal/tsar_mips32/core/hal_kentry.S

    r62 r121  
    4242# - In both cases, when the handler returns:
    4343#   . we restore the context
    44 #   . we reactivate the MMU ???
     44#   . we reactivate the MMU ??? TODO
    4545#---------------------------------------------------------------------------------
    4646
  • trunk/hal/tsar_mips32/core/hal_kentry.h

    r62 r121  
    11/*
    2  * cpu-regs.h - mips register map
     2 * hal_kentry.h - MIPS32 registers mnemonics
    33 *
    44 * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
     
    2323#ifndef _HAL_KENTRY_H_
    2424#define _HAL_KENTRY_H_
     25
     26/***************************************************************************************
     27 * This file ... TODO
     28 **************************************************************************************/
    2529
    2630#define      KSP          0
     
    6670#define CPU_IN_KERNEL 1
    6771
    68 #endif  /* _HAL_ENTRY_H_ */
     72#endif  /* _HAL_KENTRY_H_ */
  • trunk/hal/tsar_mips32/core/hal_remote.c

    r95 r121  
    2929                    uint8_t  data )
    3030{
    31     uint32_t ptr = (uint32_t)GET_PTR( xp );
    32     uint32_t cxy = (uint32_t)GET_CXY( xp );
     31    uint32_t save_sr;
     32    uint32_t ptr = (uint32_t)GET_PTR( xp );
     33    uint32_t cxy = (uint32_t)GET_CXY( xp );
     34
     35    hal_disable_irq( &save_sr );
    3336
    3437    asm volatile(
     
    4144        ".set reorder                \n"
    4245        : : "r" (data), "r" (ptr), "r" (cxy) : "$15" );
     46
     47    hal_restore_irq( save_sr );
     48
    4349}
    4450
     
    4753                    uint32_t  data )
    4854{
    49     uint32_t ptr = (uint32_t)GET_PTR( xp );
    50     uint32_t cxy = (uint32_t)GET_CXY( xp );
     55    uint32_t save_sr;
     56    uint32_t ptr = (uint32_t)GET_PTR( xp );
     57    uint32_t cxy = (uint32_t)GET_CXY( xp );
     58
     59    hal_disable_irq( &save_sr );
    5160
    5261    asm volatile( "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT */   
     
    5867        ".set reorder                \n"
    5968        : : "r" (data), "r" (ptr), "r" (cxy) : "$15" );
     69
     70    hal_restore_irq( save_sr );
     71
    6072}
    6173
     
    6476                     uint64_t  data )
    6577{
     78    uint32_t save_sr;
    6679    uint32_t ptr = (uint32_t)GET_PTR( xp );
    6780    uint32_t cxy = (uint32_t)GET_CXY( xp );
     
    6982    uint32_t data_lsb = (uint32_t)data;
    7083    uint32_t data_msb = (uint32_t)(data>>32);
     84
     85    hal_disable_irq( &save_sr );
    7186
    7287    asm volatile(
     
    8095        ".set reorder                \n"
    8196        : : "r" (data_lsb), "r" (data_msb), "r" (ptr), "r" (cxy) : "$15" );
     97
     98    hal_restore_irq( save_sr );
     99
    82100}
    83101
     
    92110uint8_t hal_remote_lb( xptr_t  xp )
    93111{
     112    uint32_t save_sr;
    94113        char     data;
    95114    uint32_t ptr = (uint32_t)GET_PTR( xp );
    96115    uint32_t cxy = (uint32_t)GET_CXY( xp );
     116
     117    hal_disable_irq( &save_sr );
    97118
    98119    asm volatile(
     
    105126        : "=r" (data) : "r" (ptr), "r" (cxy) : "$15" );
    106127
     128    hal_restore_irq( save_sr );
     129
    107130        return ( data );
    108131}
     
    111134uint32_t hal_remote_lw( xptr_t  xp )
    112135{
     136    uint32_t save_sr;
    113137        uint32_t data;
    114138    uint32_t ptr = (uint32_t)GET_PTR( xp );
    115139    uint32_t cxy = (uint32_t)GET_CXY( xp );
     140
     141    hal_disable_irq( &save_sr );
    116142
    117143    asm volatile(
     
    124150        : "=r" (data) : "r" (ptr), "r" (cxy) : "$15" );
    125151
     152    hal_restore_irq( save_sr );
     153
    126154    return ( data );
    127155}
     
    130158uint64_t hal_remote_lwd( xptr_t  xp )
    131159{
     160    uint32_t save_sr;
    132161    uint32_t data_lsb;
    133162    uint32_t data_msb;
    134163    uint32_t ptr = (uint32_t)GET_PTR( xp );
    135164    uint32_t cxy = (uint32_t)GET_CXY( xp );
     165
     166    hal_disable_irq( &save_sr );
    136167
    137168    asm volatile(
     
    145176        : "=r" (data_lsb), "=r"(data_msb) : "r" (ptr), "r" (cxy) : "$15" );
    146177
     178    hal_restore_irq( save_sr );
     179
    147180    return ( (((uint64_t)data_msb)<<32) + (((uint64_t)data_lsb)) );
     181
    148182}
    149183
     
    159193                              uint32_t  new )
    160194{
     195    uint32_t save_sr;
    161196        bool_t   isAtomic;
    162197    uint32_t ptr = (uint32_t)GET_PTR( xp );
    163198    uint32_t cxy = (uint32_t)GET_CXY( xp );
     199
     200    hal_disable_irq( &save_sr );
    164201
    165202    asm volatile(
     
    181218                : "$3", "$7", "$8", "$15" );
    182219
     220    hal_restore_irq( save_sr );
     221
    183222        return isAtomic;
    184 }
     223
     224}  // end hal_remote_atomic_cas()
    185225
    186226////////////////////////////////////////////
     
    188228                                uint32_t incr )
    189229{       
     230    uint32_t save_sr;
    190231        uint32_t current;
    191232    uint32_t ptr = (uint32_t)GET_PTR( xp );
    192233    uint32_t cxy = (uint32_t)GET_CXY( xp );
     234
     235    hal_disable_irq( &save_sr );
    193236
    194237    asm volatile(
     
    206249                : "=&r" (current) : "r" (ptr), "r" (incr), "r" (cxy) : "$3", "$15" );
    207250
     251    hal_restore_irq( save_sr );
     252
    208253        return current;
    209 }
     254
     255}  // end hal_remote_atomic_add()
    210256
    211257////////////////////////////////////////////
     
    213259                                uint32_t mask )
    214260{       
     261    uint32_t save_sr;
    215262        uint32_t current;
    216263    uint32_t ptr = (uint32_t)GET_PTR( xp );
    217264    uint32_t cxy = (uint32_t)GET_CXY( xp );
     265
     266    hal_disable_irq( &save_sr );
    218267
    219268    asm volatile(
     
    231280            : "=&r" (current) : "r" (ptr), "r" (mask), "r" (cxy) : "$3", "$15" );
    232281
     282    hal_restore_irq( save_sr );
     283
    233284        return current;
    234 }
     285
     286}  // end hal_remote_atomic_and()
    235287
    236288////////////////////////////////////////////
     
    238290                               uint32_t mask )
    239291{       
     292    uint32_t save_sr;
    240293        uint32_t current;
    241294    uint32_t ptr = (uint32_t)GET_PTR( xp );
    242295    uint32_t cxy = (uint32_t)GET_CXY( xp );
     296
     297    hal_disable_irq( &save_sr );
    243298
    244299    asm volatile(
     
    256311            : "=&r" (current) : "r" (ptr), "r" (mask), "r" (cxy) : "$3", "$15" );
    257312
     313    hal_restore_irq( save_sr );
     314
    258315        return current;
    259 }
     316
     317}  // end hal_remote_atomic_or()
    260318
    261319/////////////////////////////////////////////////
     
    264322                                   uint32_t * old )
    265323{
     324    uint32_t save_sr;
    266325        uint32_t current;
    267326        error_t  error;
    268327    uint32_t ptr = (uint32_t)GET_PTR( xp );
    269328    uint32_t cxy = (uint32_t)GET_CXY( xp );
     329
     330    hal_disable_irq( &save_sr );
    270331
    271332    asm volatile(
     
    277338        "sc     $3,     (%2)         \n"  /* *paddr <= $3         */
    278339        "beq    $3,     $0,     1f   \n"  /* exit if failure      */
    279         "ori    %1,     $0,      1   \n"        /* fail: ret <= 1       */
    280         "and    %1,     $0,     $0   \n"        /* success: ret <= 0    */
     340        "ori    %1,     $0,      1   \n"  /* fail: ret <= 1       */
     341        "and    %1,     $0,     $0   \n"  /* success: ret <= 0    */
    281342        "1:                          \n"
    282343        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
     
    284345                : "=&r" (current), "=&r" (error) : "r" (ptr), "r" (incr), "r" (cxy) : "$3", "$15" );
    285346               
     347    hal_restore_irq( save_sr );
     348
    286349    *old = current;
    287350               
    288351        return error;
    289 }
     352
     353}  // end hal_remote_atomic_try_add()
    290354
    291355/////////////////////////////////////
     
    294358                        uint32_t size )
    295359{
     360    uint32_t save_sr;
    296361        uint32_t i;
    297362        uint32_t wsize;
     
    300365    uint32_t sptr = (uint32_t)GET_PTR( src );
    301366    uint32_t scxy = (uint32_t)GET_CXY( src );
     367
     368    hal_disable_irq( &save_sr );
    302369
    303370        if( (dptr & 0x3) || (sptr & 0x3) ) wsize = 0;  // do it all in bytes
     
    331398                    : : "r"(scxy), "r" (sptr+i), "r"(dcxy), "r" (dptr+i) : "$3", "$15" );               
    332399        }
    333 }
    334 
    335 
     400
     401    hal_restore_irq( save_sr );
     402
     403}  // end hal_remote_memcpy()
     404
     405///////////////////////////////////
     406void hal_remote_strcpy( xptr_t dst,
     407                        xptr_t src )
     408{
     409    uint32_t save_sr;
     410    uint32_t dptr = (uint32_t)GET_PTR( dst );
     411    uint32_t dcxy = (uint32_t)GET_CXY( dst );
     412    uint32_t sptr = (uint32_t)GET_PTR( src );
     413    uint32_t scxy = (uint32_t)GET_CXY( src );
     414
     415    hal_disable_irq( &save_sr );
     416
     417    // loop on characters while non NUL
     418    asm volatile(
     419        "mfc2   $15,   $24          \n"   /* $15 <= PADDR_EXT               */
     420        "1:                         \n"   /* loop entry                     */
     421        "mtc2   %0,    $24          \n"   /* PADDR_EXT <= scxy              */   
     422        "lb         $13,   0(%1)        \n"   /* read char from src string      */
     423        "mtc2   %2,    $24          \n"   /* PADDR_EXT <= dcxy              */   
     424            "sb     $13,   0(%3)        \n"   /* store char to dst string       */
     425        "addi   %1,    %1,  1       \n"   /* increment sptr pointer         */
     426        "addi   %3,    %3,  1       \n"   /* increment dptr pointer         */
     427        "bne    $13,   $0,  1b      \n"   /* test NUL                       */
     428        "nop                        \n"
     429        "mtc2   $15,   $24          \n"   /* PADDR_EXT <= $15               */   
     430        : : "r"(scxy), "r"(sptr), "r"(dcxy), "r"(dptr) : "$13","$15", "memory" );
     431
     432    hal_restore_irq( save_sr );
     433
     434} // end hal_remote_strcpy()
  • trunk/hal/tsar_mips32/core/hal_special.c

    r101 r121  
    3333
    3434
    35 ///////////////////
    36 gid_t hal_get_gid()
     35//////////////////////////
     36inline gid_t hal_get_gid()
    3737{
    3838        uint32_t proc_id;
     
    4141
    4242        return (proc_id & 0x3FF);  // 4/4/2 format for TSAR
     43}
     44
     45////////////////////////////////
     46inline cycle_t hal_time_stamp()
     47{
     48    cycle_t count;
     49
     50        asm volatile ("mfc0   %0,  $9  " : "=&r" (count));
     51
     52    return count;
    4353}
    4454
     
    5767
    5868    // get current time stamp from hardware register
    59         asm volatile ("mfc0   %0,  $9  " : "=&r" (current_count));
     69        current_count = hal_time_stamp();
    6070
    6171        // compute number of elapsed cycles, taking into account 32 bits register wrap
     
    7585}
    7686
    77 //////////////////////////////////////////
    78 struct thread_s * hal_get_current_thread()
     87/////////////////////////////////////////////////
     88inline struct thread_s * hal_get_current_thread()
    7989{
    8090        void * thread_ptr;
  • trunk/hal/tsar_mips32/core/hal_uspace.c

    r87 r121  
    128128
    129129//////////////////////////////////////////
    130 void hal_strcpy_from_uspace( char * k_dst,
    131                              char * u_src )
    132 
    133 {
     130void hal_strcpy_from_uspace( char     * k_dst,
     131                             char     * u_src,
     132                             uint32_t   max_size )
     133
     134{
     135
     136// TODO implement the max_size handling
     137
    134138    uint32_t save_sr;
    135139    uint32_t src = (uint32_t)u_src;
     
    157161} // hal_strcpy_from_uspace()
    158162
    159 //////////////////////////////////////////
    160 void hal_strcpy_to_uspace( char * u_dst,
    161                            char * k_src )
    162 
    163 {
     163////////////////////////////////////////////
     164void hal_strcpy_to_uspace( char     * u_dst,
     165                           char     * k_src,
     166                           uint32_t   max_size )
     167{
     168
     169// TODO implement the max_size handling
     170
    164171    uint32_t save_sr;
    165172    uint32_t src = (uint32_t)k_src;
Note: See TracChangeset for help on using the changeset viewer.