Changeset 279 for trunk/hal


Ignore:
Timestamp:
Jul 27, 2017, 12:23:29 AM (4 years ago)
Author:
alain
Message:

1) Introduce independant command fields for the various devices in the thread descriptor.
2) Introduce a new dev_pic_enable_ipi() function in the generic PIC device
3) Fix two bugs identified by Maxime in the scheduler initialisation, and in the sched_select().
4) fix several bugs in the TSAR hal_kentry.S.
5) Introduce a third kgiet segment (besides kdata and kcode) in the TSAR bootloader.

Location:
trunk/hal
Files:
19 edited

Legend:

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

    r17 r279  
    3838/*****************************************************************************************
    3939 * This function disables all IRQs, and saves the CPU SR state if required.
    40  * TODO : Warning this function discards the CU3 access bit
    4140 *****************************************************************************************
    4241 * @ old    : address of buffer to save the SR (no save if NULL).
  • trunk/hal/generic/hal_special.h

    r124 r279  
    3636// ALMOS-MKH uses the following API to access the MMU and other core protected registers.
    3737///////////////////////////////////////////////////////////////////////////////////////////
     38
     39/*****************************************************************************************
     40 * This function returns the calling core status register value.
     41 ****************************************************************************************/
     42inline reg_t hal_get_sr();
    3843
    3944/*****************************************************************************************
  • trunk/hal/tsar_mips32/core/hal_drivers.c

    r266 r279  
    7575        /* update the PIC chdev extension */
    7676        pic->ext.pic.enable_timer = &soclib_pic_enable_timer;
     77        pic->ext.pic.enable_ipi   = &soclib_pic_enable_ipi;
    7778        pic->ext.pic.enable_irq   = &soclib_pic_enable_irq;
    7879        pic->ext.pic.disable_irq  = &soclib_pic_disable_irq;
  • trunk/hal/tsar_mips32/core/hal_interrupt.c

    r238 r279  
    2323
    2424#include <hal_types.h>
     25#include <hal_special.h>
    2526#include <kernel_config.h>
    2627#include <thread.h>
     28#include <printk.h>
    2729#include <do_interrupt.h>
    2830#include <hal_interrupt.h>
    29 #include <mips32_uzone.h>
    3031#include <soclib_pic.h>
    3132
     
    3435                               reg_t    * regs_tbl )
    3536{
     37    irq_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
     38
    3639        // update user time     
    3740        thread_user_time_update( this );
     
    4548        // update kernel time
    4649        thread_kernel_time_update( this );
     50
     51    irq_dmsg("\n[INFO] %s : exit at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
    4752}
  • trunk/hal/tsar_mips32/core/hal_irqmask.c

    r62 r279  
    2828inline void hal_disable_irq( uint32_t * old )
    2929{
    30         register unsigned int sr;
     30        register uint32_t sr;
    3131       
    3232        __asm__ volatile
    3333                (".set noat                          \n"
    34                  ".set noreorder                     \n"
    35                  "mfc0   $1,     $12                 \n"
    36                  "nop                                \n"
    37                  ".set reorder                       \n"
     34         "mfc0   $1,     $12                 \n"
    3835                 "or     %0,     $0,     $1          \n"
    3936                 "srl    $1,     $1,     1           \n"
    4037                 "sll    $1,     $1,     1           \n"
    4138                 "mtc0   $1,     $12                 \n"
    42                 ".set at                            \n"
    43                  : "=&r" (sr));
     39        ".set at                            \n"
     40                 : "=&r" (sr) );
    4441
    4542        if( old ) *old = sr;
     
    4946inline void hal_enable_irq( uint32_t * old )
    5047{
    51         register unsigned int sr;
     48        register uint32_t sr;
    5249 
    5350        __asm__ volatile
    5451                (".set noat                          \n"
    55                  ".set noreorder                     \n"
    5652                 "mfc0   $1,     $12                 \n"
    57                  "nop                                \n"
    5853                 "or     %0,     $0,     $1          \n"
    59                  "ori    $1,     $1,     0x1         \n"
     54                 "ori    $1,     $1,     0xFF01      \n"
    6055                 "mtc0   $1,     $12                 \n"
    61                  "nop                                \n"
    62                  ".set reorder                       \n"
    63                  ".set at                            \n"
    64                  : "=&r" (sr));
     56         ".set at                            \n"
     57                 : "=&r" (sr) );
    6558 
    6659        if( old ) *old = sr;
     
    7164{
    7265        __asm__ volatile
    73                 (".set noat                          \n"
    74                  ".set noreorder                     \n"
    75                  "mfc0    $1,    $12                 \n"
    76                  "ori     $2,    $0,      0xFF       \n"
    77                  "and     $2,    $2,      %0         \n"
    78                  "or      $1,    $1,      $2         \n"
    79                  "mtc0    $1,    $12                 \n"
    80                  ".set reorder                       \n"
    81                  ".set at                            \n"
    82                  : : "r" (old) : "$2");
     66                ( "mtc0    %0,    $12" : : "r" (old) );
    8367}
    8468
     69
  • trunk/hal/tsar_mips32/core/hal_kentry.S

    r121 r279  
    11/*
    2  * hal_kentry.S - exception/interrupt/syscall kernel entry point for MIPS32
     2 * hal_kentry.S - Interrupt / Exception / Syscall kernel entry point for MIPS32
    33 *
    44 * AUthors   Ghassan Almaless (2007,2008,2009,2010,2011,2012)
     
    3030# or syscall for the TSAR_MIPS32 architecture. 
    3131#
    32 # - If the core is in user mode:
    33 #   . we desactivate the MMU.
    34 #   . we save the context in the uzone of the calling thread descriptor.
    35 #   . we increment the cores_in_kernel variable.
    36 #   . we call the relevant exception/interrupt/syscall handler
     32# When we enter the kernel, we test the ststus register:
     33# - If the core is in user mode, we desactivate the MMU, and we save
     34#   the core context in the uzone of the calling thread descriptor.
     35# - If the core is already in kernel mode (in case of interrupt),
     36#   we save the context in the kernel stack.
     37# - In both cases, we increment the cores_in_kernel variable,
     38#   and we call the relevant exception/interrupt/syscall handler
    3739#
    38 # - If the core is already in kernel mode:
    39 #   . we save the context in the kernel stack
    40 #   . we call the relevant exception/interrupt/syscall handler
    41 #
    42 # - In both cases, when the handler returns:
    43 #   . we restore the context
    44 #   . we reactivate the MMU ??? TODO
     40# When we exit the kernel after handler execution:
     41# - we restore the core context from the uzone
    4542#---------------------------------------------------------------------------------
    4643
    47         .section   .kentry,"ax",@progbits
    48         .extern    cpu_do_interrupt
    49         .extern    cpu_do_exception
    50         .extern    cpu_do_syscall
    51         .extern    cpu_kentry
    52         .extern    cpu_kexit
     44        .section   .kgiet, "ax", @progbits
     45
     46        .extern    hal_do_interrupt
     47        .extern    hal_do_exception
     48        .extern    hal_do_syscall
     49        .extern    cluster_core_kernel_enter
     50        .extern    cluster_core_kernel_exit
     51
    5352        .org       0x180
    54         .ent       kentry
    55         .global    kentry
    56         .global    kentry_load
     53        .ent       kernel_enter
     54        .global    kernel_enter
     55
    5756        .set       noat
    5857        .set       noreorder
     
    6766
    6867#---------------------------------------------------------------------------------
    69 # Kernel Entry point
     68# Kernel Entry point for Interrupt / Exception / Syscall
    7069#---------------------------------------------------------------------------------
    7170
    72 kentry:
     71kernel_enter:
    7372        mfc0    $26,    $12                 # read SR to test user/kernel mode
    7473        andi    $26,    $26,  0x10          # User Mode bitmask
     
    101100#---------------------------------------------------------------------------------------       
    102101# this code is executed when the core is in kernel mode:
    103 # - we use an uzone allocated in kernel stack.
     102# - we use an uzone dynamically allocated in kernel stack.
    104103# - we set the MMU off, set the MMU data_paddr extension to local_cxy,
    105104#   and save the CP2_MODE and CP2_DEXT to uzone.
     
    141140
    142141#--------------------------------------------------------------------------------------
    143 # this code is executed in both modes, with the two following assumptions:
    144 # - $27 contains the pointer on uzone to save the cpu registers
     142# This code is executed in both modes, and saves the core context,
     143# with the two following assumptions:
     144# - $27 contains the pointer on uzone to save the core registers
    145145# - $29 contains the kernel stack pointer
    146146
     
    186186        sw      $17,    (UZ_CR*4)($27)          # Save CR
    187187
    188         srl         $3,     $18,  5                 # put SR in kernel mode, IRQ disabled, clear exl
     188    # put SR in kernel mode, IRQ disabled, clear exl
     189        srl         $3,     $18,  5
    189190        sll     $3,         $3,   5     
    190191        mtc0    $3,         $12                         # Set new SR
    191192
    192         andi    $1,     $17,  0x3F          # $1 <= XCODE (from CR)
    193 
    194193        # signal that core enters kernel
    195         jal         cluster_core_kernel_enter
     194        la      $1,     cluster_core_kernel_enter
     195        jal         $1
    196196    nop
    197197
    198198#---------------------------------------------------------------------------------------
    199 # Depending on XCODE (in $1) , call the apropriate handler. The three called
    200 # functions take the same two arguments: thread pointer and uzone pointer.
     199# This code call the relevant Interrupt / Exception / Syscall handler,
     200# depending on XCODE in CP0_CR, with the two following assumptions:
     201# - $27 contains the pointer on uzone containing to save the core registers
     202# - $29 contains the kernel stack pointer
     203# The three handlers take the same two arguments: thread pointer and uzone pointer.
     204# The uzone pointer is saved in $19 to be used by kernel_exit.
     205
     206        mfc0    $17,    $13                 # $1 <= CR
     207        andi    $1,     $1,   0x3F          # $1 <= XCODE
    201208
    202209        mfc0    $4,     $4,   2             # $4 <= thread pointer (first arg)
    203210        or          $5,     $0,   $27               # $5 <= uzone pointer (second arg)
    204         or          $19,    $0,   $27           # $19 <= &uzone (for kentry_exit)
     211        or          $19,    $0,   $27           # $19 <= &uzone (for kernel_exit)
    205212
    206213        ori         $8,     $0,   0x20          # $8 <= cause syscall
     
    215222        addiu   $29,    $29,  -8                # hal_do_exception has 2 args
    216223        addiu   $29,    $29,  8
    217         j       kentry_exit                 # jump to kentry_exit
     224        j       kernel_exit                 # jump to kernel_exit
    218225    nop
    219226
     
    223230        addiu   $29,    $29,  -8            # hal_do_syscall has 2 args
    224231        addiu   $29,    $29,  8
    225         j           kentry_exit                 # jump to kentry_exit
    226         or          $19,        $0,   $2
     232        j           kernel_exit                 # jump to kernel_exit
     233        nop
    227234       
    228235cause_int:
     
    233240
    234241# -----------------------------------------------------------------------------------
    235 # Kentry exit
     242# Kernel exit
     243# The pointer on uzone is supposed to be stored in $19
    236244# -----------------------------------------------------------------------------------
    237 kentry_exit:
     245kernel_exit:
    238246
    239247        # signal that core exit kernel
    240     jal     cluster_core_kernel_exit
     248    la      $1,     cluster_core_kernel_exit
     249    jalr    $1
     250    nop
    241251
    242252        # restore context from uzone
     
    286296        lw          $31,        (UZ_RA*4)($27)
    287297
    288 
    289298        lw          $26,    (UZ_DEXT*4)($27)
    290299        mtc2    $26,    $24                             # restore CP2_DEXT from uzone
    291300
    292     #TODO: optimize
    293         lw          $26,    (UZ_MODE*4)($27)    # get saved CP2_MODE from uzone
    294         andi    $26,    $26,    0xc         # keep only the TLBs controling bits
    295         beq     $26,    $0,         out_mmu_3   # both MSB are 0 (the first two LSB are always set)
    296         andi    $26,    $26,    0x8
    297         beq     $26,    $0,         out_mmu_7   # first MSB is 0 (bit 2 is set)
    298 
    299 # Possible value for MMU_MODE
    300 # In kernel mode : 0x7/0x3
    301 # In user mode   : 0xF
    302 
    303 # DP_EXT can either be local or remote
    304 # Once these register set we can no longuer
    305 # access global data
    306 
    307 out_mmu_F:
    308         ori         $26,        $0,        0xF
    309         mtc2    $26,    $1                              # CP2_MODE <= 0xF
    310         j           out_kentry
    311         nop
    312 
    313 out_mmu_7:
    314         ori         $26,    $0,    0x7 
    315         mtc2    $26,    $1                              # CP2_MODE <= 0x7
    316         j       out_kentry
    317         nop
    318 
    319 out_mmu_3:
    320         ori     $26,    $0,        0x3
    321         mtc2    $26,    $1                              # CP2_MODE <= 0x3
    322 
    323 out_kentry:
     301        lw          $26,    (UZ_MODE*4)($27)   
     302    mtc2    $26,    $1                  # restore CP2_MODE from uzone
     303
    324304        nop
    325305    eret
    326306
    327     .end kentry
     307    .end kernel_enter
    328308    .set reorder
    329309    .set at
    330310
    331         .ent kentry_load
    332 kentry_load:
    333         # theses nops are required to load the eret instruction
    334         # while we are in virtual mode (processor pipeline) ?
    335         mtc2     $26,    $1            # set MMU MODE
    336         nop                     
    337         nop
    338     eret
    339     .end kentry_load
    340 
    341311#-------------------------------------------------------------------------------
    342312
  • trunk/hal/tsar_mips32/core/hal_kentry.h

    r121 r279  
    2424#define _HAL_KENTRY_H_
    2525
    26 /***************************************************************************************
    27  * This file ... TODO
    28  **************************************************************************************/
    29 
    30 #define      KSP          0
    31 #define      AT           1
    32 #define      V0           2
    33 #define      V1           3
    34 #define      A0           4
    35 #define      A1           5
    36 #define      A2           6
    37 #define      A3           7
    38 #define      T0           8
    39 #define      T1           9
    40 #define      T2           10
    41 #define      T3           11
    42 #define      T4           12
    43 #define      T5           13
    44 #define      T6           14
    45 #define      T7           15
    46 #define      T8           16
    47 #define      T9           17
    48 #define      S0           18
    49 #define      S1           19
    50 #define      S2           20
    51 #define      S3           21
    52 #define      S4           22
    53 #define      S5           23
    54 #define      S6           24
    55 #define      S7           25
    56 #define      S8           26
    57 #define      GP           27
    58 #define      RA           28
    59 #define      EPC          29
    60 #define      CR           30
    61 #define      SP           31
    62 #define      SR           32
    63 #define      LO           33
    64 #define      HI           34
    65 #define      TLS_K1       35
    66 #define      DP_EXT           36   // DATA PADDR EXTENSION
    67 #define      MMU_MD           37   // MMU MODE
    68 #define      REGS_NR      38
    6926
    7027#define CPU_IN_KERNEL 1
  • trunk/hal/tsar_mips32/core/hal_ppm.c

    r107 r279  
    3939// - the 64 bits XPTR value is identical to the 64 bits PADDR value.
    4040// The pages_tbl[] is mapped in first free page after kernel code.
    41 // There is no other reserved zones than the zone occupied by the kernel code.
    4241//////////////////////////////////////////////////////////////////////////////////////////
    43 
    4442
    4543///////////////////////////////////////////
     
    5250        uint32_t pages_tbl_offset = info->pages_offset;
    5351        uint32_t rsvd_nr          = info->rsvd_nr;
    54 
    55         // check no reserved zones other than kernel code for TSAR
    56         assert( (rsvd_nr == 0 ) , __FUNCTION__ , "NO reserved zones for TSAR\n" );
    5752
    5853        // get pointer on local Physical Page Manager
  • trunk/hal/tsar_mips32/core/hal_remote.c

    r204 r279  
    3434    uint32_t cxy = (uint32_t)GET_CXY( xp );
    3535
    36     hal_disable_irq( &save_sr );
    37 
    38     asm volatile(
    39         ".set noreorder              \n"
    40         "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT */   
    41         "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy */   
    42         "sb     %0,     0(%1)        \n"  /* *paddr <= value  */
    43         "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15 */   
     36/* TODO improve all hal remote functions to include SR handling in assembly code */
     37/* as it is done below for hal_remote_sb                                         */
     38
     39    asm volatile(
     40        ".set noreorder              \n"
     41        "mfc0   $14,    $12          \n"  /* $14 <= CP0_SR      */
     42        "srl    $13,    $14,    1    \n"
     43        "sll    $13,    $13,    1    \n"  /* $13 <= SR masked   */
     44        "mtc0   $13,    $12          \n"  /* IRQ disabled       */
     45       
     46
     47        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */   
     48        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy   */   
     49        "sb     %0,     0(%1)        \n"  /* *paddr <= value    */
     50        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
     51
     52        "mtc0   $14,    $12          \n"  /* SR restored        */
     53
    4454        "sync                        \n"
    4555        ".set reorder                \n"
    46         : : "r" (data), "r" (ptr), "r" (cxy) : "$15" );
    47 
    48     hal_restore_irq( save_sr );
    49 
     56        : : "r" (data), "r" (ptr), "r" (cxy) : "$13", "$14", "$15" );
    5057}
    5158
  • trunk/hal/tsar_mips32/core/hal_special.c

    r124 r279  
    3232struct thread_s;
    3333
     34/////////////////////////////////
     35void hal_set_ebase( reg_t  base )
     36{
     37        asm volatile ("mtc0    %0,  $15,  1" : : "r" (base));
     38}
    3439
    3540//////////////////////////
     
    4853    cycle_t count;
    4954
    50         asm volatile ("mfc0   %0,  $9  " : "=&r" (count));
     55        asm volatile ("mfc0   %0,  $9" : "=&r" (count));
    5156
    5257    return count;
     58}
     59
     60/////////////////////////
     61inline reg_t hal_get_sr()
     62{
     63    register uint32_t sr;
     64
     65        asm volatile ("mfc0    %0,    $12" : "=&r" (sr));
     66
     67        return sr;
    5368}
    5469
     
    90105        void * thread_ptr;
    91106 
    92         asm volatile
    93     ( "mfc0    %0,  $4,  2  \n"
    94       : "=&r" (thread_ptr)  );
     107        asm volatile ("mfc0    %0,  $4,  2" : "=&r" (thread_ptr));
    95108
    96109        return thread_ptr;
     
    100113void hal_set_current_thread( struct thread_s * thread )
    101114{
    102         asm volatile
    103     ( "mtc0    %0,  $4,  2  \n"
    104       : : "r" (thread) );
     115        asm volatile ("mtc0    %0,  $4,  2" : : "r" (thread));
    105116}
    106117
     
    135146        register uint32_t sp;
    136147 
    137         asm volatile
    138         ( "or    %0,   $0,   $29  \n"
    139        : "=&r" (sp) );
     148        asm volatile ("or    %0,   $0,   $29" : "=&r" (sp));
    140149 
    141150        return sp;
  • trunk/hal/tsar_mips32/drivers/soclib_bdv.c

    r265 r279  
    5858void __attribute__ ((noinline)) soclib_bdv_cmd( xptr_t th_xp )
    5959{
    60     uint32_t   cmd_type;     // IOC_READ / IOC_WRITE / IOC_SYNC_READ
    61     uint32_t   lba;          // command argument
    62     uint32_t   count;        // command argument
    63     xptr_t     buf_xp;       // command argument
    64     xptr_t     dev_xp;       // command argument
     60    uint32_t   cmd_type;    // IOC_READ / IOC_WRITE / IOC_SYNC_READ
     61    uint32_t   lba;
     62    uint32_t   count;
     63    xptr_t     buf_xp;
     64    xptr_t     ioc_xp;
    6565
    6666    // get client thread cluster and local pointer
     
    6969
    7070    // get command arguments and extended pointer on IOC device
    71     cmd_type =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.type   ) );
    72     lba      =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.lba    ) );
    73     count    =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.count  ) );
    74     buf_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.buf_xp ) );
    75     dev_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.dev_xp ) );
     71    cmd_type =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.type   ) );
     72    lba      =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.lba    ) );
     73    count    =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.count  ) );
     74    buf_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.buf_xp ) );
     75    ioc_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.dev_xp ) );
    7676
    7777    // get IOC device cluster and local pointer
    78     cxy_t      dev_cxy = GET_CXY( dev_xp );
    79     chdev_t  * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
     78    cxy_t      ioc_cxy = GET_CXY( ioc_xp );
     79    chdev_t  * ioc_ptr = (chdev_t *)GET_PTR( ioc_xp );
    8080
    8181    // get extended pointer on SOCLIB-BDV peripheral
    82     xptr_t     bdv_xp = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->base ) );
     82    xptr_t     bdv_xp = hal_remote_lw( XPTR( ioc_cxy , &ioc_ptr->base ) );
    8383
    8484    // get SOCLIB_BDV device cluster and local pointer
     
    114114            if( status == BDV_READ_SUCCESS ) // successfully completed
    115115            {
    116                 hal_remote_sw( XPTR( th_cxy , &th_ptr->command.ioc.error ) , 0 );
     116                hal_remote_sw( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 0 );
    117117                break;
    118118            }
     
    123123            else                            // error reported
    124124            {
    125                 hal_remote_sw( XPTR( th_cxy , &th_ptr->command.ioc.error ) , 1 );
     125                hal_remote_sw( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 1 );
    126126                break;
    127127            }
     
    161161        if((status != BDV_READ_SUCCESS) && (status != BDV_WRITE_SUCCESS))
    162162    {
    163         hal_remote_sw( XPTR( client_cxy , &client_ptr->command.ioc.error ) , 1 );
     163        hal_remote_sw( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , 1 );
    164164    }
    165165        else
    166166    {
    167         hal_remote_sw( XPTR( client_cxy , &client_ptr->command.ioc.error ) , 0 );
     167        hal_remote_sw( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , 0 );
    168168    }
    169169
  • trunk/hal/tsar_mips32/drivers/soclib_dma.c

    r261 r279  
    5757
    5858    // get command arguments and extended pointer on DMA device
    59     dev_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->command.dma.dev_xp ) );
    60     dst_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->command.dma.dst_xp ) );
    61     src_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->command.dma.src_xp ) );
    62     size   =         hal_remote_lw ( XPTR( thread_cxy , &thread_ptr->command.dma.size   ) );
     59    dev_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->dma_cmd.dev_xp ) );
     60    dst_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->dma_cmd.dst_xp ) );
     61    src_xp = (xptr_t)hal_remote_lwd( XPTR( thread_cxy , &thread_ptr->dma_cmd.src_xp ) );
     62    size   =         hal_remote_lw ( XPTR( thread_cxy , &thread_ptr->dma_cmd.size   ) );
    6363
    6464    // get DMA device cluster and local pointer
     
    124124    // set operation status in command
    125125        error_t  error = ( status != DMA_SUCCESS );
    126     hal_remote_sw( XPTR( client_cxy , &client_ptr->command.dma.error ) , error );
     126    hal_remote_sw( XPTR( client_cxy , &client_ptr->dma_cmd.error ) , error );
    127127
    128128    // unblock server thread
  • trunk/hal/tsar_mips32/drivers/soclib_hba.c

    r211 r279  
    107107
    108108    // get command arguments and extended pointer on IOC device
    109     cmd_type  =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.type   ) );
    110     lba       =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.lba    ) );
    111     count     =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.count  ) );
    112     buf_xp    = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.buf_xp ) );
    113     dev_xp    = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.dev_xp ) );
     109    cmd_type  =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.type   ) );
     110    lba       =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.lba    ) );
     111    count     =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->ioc_cmd.count  ) );
     112    buf_xp    = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.buf_xp ) );
     113    dev_xp    = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->ioc_cmd.dev_xp ) );
    114114
    115115    // get IOC device cluster and local pointer
     
    225225                if( error && (fault_id == cmd_id) )
    226226                {
    227                     hal_remote_sw( XPTR( th_cxy , &th_ptr->command.ioc.error ) , 1 );
     227                    hal_remote_sw( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 1 );
    228228                }
    229229                else
    230230                {
    231                     hal_remote_sw( XPTR( th_cxy , &th_ptr->command.ioc.error ) , 0 );
     231                    hal_remote_sw( XPTR( th_cxy , &th_ptr->ioc_cmd.error ) , 0 );
    232232                }
    233233
     
    281281            if( error && (iter == fault_id ) )
    282282            {
    283                 hal_remote_sw( XPTR( client_cxy , &client_ptr->command.ioc.error ) , 1 );
     283                hal_remote_sw( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , 1 );
    284284            }
    285285            else
    286286            {
    287                 hal_remote_sw( XPTR( client_cxy , &client_ptr->command.ioc.error ) , 0 );
     287                hal_remote_sw( XPTR( client_cxy , &client_ptr->ioc_cmd.error ) , 0 );
    288288            }
    289289
  • trunk/hal/tsar_mips32/drivers/soclib_mmc.c

    r257 r279  
    11/*
    2  * soclib_mmc.c - soclib simple block device driver implementation.
     2 * soclib_mmc.c - soclib L2 cache controller driver implementation.
    33 *
    44 * Author     Alain Greiner (2016)
     
    6262
    6363    // get command type and extended pointer on MMC device
    64     type   =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.mmc.type   ) );
    65     dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.mmc.dev_xp ) );
     64    type   =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->mmc_cmd.type   ) );
     65    dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->mmc_cmd.dev_xp ) );
    6666
    6767    // get MMC device cluster and local pointer
     
    7979    {
    8080        // get buffer paddr
    81         buf_paddr = hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.mmc.buf_paddr ) );
     81        buf_paddr = hal_remote_lwd( XPTR( th_cxy , &th_ptr->mmc_cmd.buf_paddr ) );
    8282
    8383        // split buffer paddr in two 32 bits words
     
    8686
    8787        // get buffer size
    88         buf_size   = hal_remote_lw( XPTR( th_cxy , &th_ptr->command.mmc.buf_size ) );
     88        buf_size   = hal_remote_lw( XPTR( th_cxy , &th_ptr->mmc_cmd.buf_size ) );
    8989
    9090        // get command type
     
    102102    {
    103103        // get src/dst buffer local pointer and register index
    104         reg_ptr   = (uint32_t *)hal_remote_lpt( XPTR( th_cxy , &th_ptr->command.mmc.reg_ptr ) );
    105         reg_index = hal_remote_lw( XPTR( th_cxy , &th_ptr->command.mmc.reg_index ) );
     104        reg_ptr   = (uint32_t *)hal_remote_lpt( XPTR( th_cxy , &th_ptr->mmc_cmd.reg_ptr ) );
     105        reg_index = hal_remote_lw( XPTR( th_cxy , &th_ptr->mmc_cmd.reg_index ) );
    106106
    107107        // move register to/from local buffer
  • trunk/hal/tsar_mips32/drivers/soclib_nic.c

    r259 r279  
    107107
    108108    // get command arguments
    109     cmd    = thread_ptr->command.nic.cmd;
    110     buffer = thread_ptr->command.nic.buffer;
    111     length = thread_ptr->command.nic.length;
    112     dev_xp = thread_ptr->command.nic.dev_xp;
     109    cmd    = thread_ptr->nic_cmd.cmd;
     110    buffer = thread_ptr->nic_cmd.buffer;
     111    length = thread_ptr->nic_cmd.length;
     112    dev_xp = thread_ptr->nic_cmd.dev_xp;
    113113
    114114    // get local pointer for device
     
    212212            {
    213213                // return chbuf writable
    214                 thread_ptr->command.nic.status = true;
     214                thread_ptr->nic_cmd.status = true;
    215215            }
    216216            else                    // current container not writable
     
    230230                     
    231231                    // return chbuf writable
    232                     thread_ptr->command.nic.status = true;
     232                    thread_ptr->nic_cmd.status = true;
    233233                }
    234234                else                            // next container full     
    235235                {
    236236                    // return chbuf non writable
    237                     thread_ptr->command.nic.status = false;
     237                    thread_ptr->nic_cmd.status = false;
    238238                }
    239239            }
     
    256256            {
    257257                // return chbuf readable     
    258                 thread_ptr->command.nic.status = true;
     258                thread_ptr->nic_cmd.status = true;
    259259            }
    260260            else                        // current container non readable
     
    274274                     
    275275                    // return chbuf readable
    276                     thread_ptr->command.nic.status = true;
     276                    thread_ptr->nic_cmd.status = true;
    277277                }
    278278                else                            // next container empty   
    279279                {
    280280                    // return chbuf non readable
    281                     thread_ptr->command.nic.status = false;
     281                    thread_ptr->nic_cmd.status = false;
    282282                }
    283283            }
  • trunk/hal/tsar_mips32/drivers/soclib_pic.c

    r205 r279  
    8383}
    8484
    85 
    86 //////////////////////////////////////////
    87 uint32_t soclib_pic_ack_timer( lid_t lid )
    88 {
    89     // get local XCU segment base
    90         uint32_t * base = soclib_pic_xcu_base();
    91 
    92     // read from register
    93         return base[(XCU_PTI_ACK << 5) | lid];
    94 
    95 }  // end soclib_pic_ack_timer()
    96 
    9785///////////////////////////////////////////
    9886void soclib_pic_xcu_status( lid_t      lid,
     
    113101}
    114102
     103////////////////////////////////////////////////////
     104inline uint32_t soclib_pic_xcu_ack( uint32_t * reg )
     105{
     106    return *reg;
     107}
     108
    115109/////////////////////////////
    116110void soclib_pic_irq_handler()
     
    120114    uint32_t   pti_status;   // PTI index + 1  / no pending PTI if 0
    121115    chdev_t  * src_chdev;    // pointer on source chdev descriptor
    122     uint32_t   index;        // IRQ index
     116    uint32_t   index;        // WTI / HWI / PTI index
     117    uint32_t   ack;          // XCU acknowledge requires a read...
    123118
    124119    core_t * core = CURRENT_THREAD->core;
     
    130125                           &pti_status );
    131126
     127    irq_dmsg("\n[INFO] %s : enter / WTI_STS = %x / HWI_STS = %x / WTI_STS = %x\n",
     128             __FUNCTION__ , wti_status , hwi_status , pti_status );
     129
    132130    // analyse status and handle up to 3 pending IRQ (one WTI, one HWI, one PTI)
    133131
     
    140138            assert( (index == core->lid) , __FUNCTION__ , "illegal IPI index" );
    141139
    142             // TODO acknowledge WTI [AG]
    143 
    144             // TODO force scheduling [AG]
     140            // acknowledge WTI
     141            uint32_t * base = soclib_pic_xcu_base();
     142            ack = base[(XCU_WTI_REG << 5) | core->lid];
     143
     144            // force scheduling
     145            sched_yield();
    145146        }
    146147        else                                    // it is an external device
     
    156157                    core->spurious_irqs ++;
    157158
    158                 // TODO disable this WTI in local XCU [AG]
     159                // disable WTI in local XCU controller
     160                uint32_t * base = soclib_pic_xcu_base();
     161                base[(XCU_MSK_WTI_DISABLE << 5) | core->lid] = 1 << core->lid;
    159162            }
    160163            else                                 // call relevant ISR
     
    183186                core->spurious_irqs ++;
    184187
    185             // TODO disable this HWI in local XCU [AG]
     188            // disable HWI in local XCU controller
     189            uint32_t * base = soclib_pic_xcu_base();
     190            base[(XCU_MSK_HWI_DISABLE << 5) | core->lid] = 1 << core->lid;
    186191                }
    187192        else                    // call relevant ISR
     
    205210
    206211        // acknowledge PTI
    207         soclib_pic_ack_timer( index );
    208 
    209         // TODO execute all actions related to TICK event
     212        uint32_t * base = soclib_pic_xcu_base();
     213        ack = base[(XCU_PTI_ACK << 5) | core->lid];
     214
     215        // execute all actions related to TICK event
    210216        core_clock( core );
    211217        }
     
    431437    else if( irq_type == SOCLIB_TYPE_WTI )
    432438    {
    433         // enable this WTI in local XCU controller
     439        // enable this WTI in remote XCU controller
    434440        hal_remote_sw( XPTR( src_chdev_cxy ,
    435441                       &seg_xcu_ptr[(XCU_MSK_WTI_ENABLE << 5) | lid] ) , (1 << irq_id) );
     
    464470    else if( irq_type == SOCLIB_TYPE_WTI )
    465471    {
    466         // enable this WTI in local XCU controller
     472        // enable this WTI in remote XCU controller
    467473        hal_remote_sw( XPTR( src_chdev_cxy ,
    468474                       &seg_xcu_ptr[(XCU_MSK_WTI_DISABLE << 5) | lid] ) , (1 << irq_id) );
     
    486492    base[(XCU_PTI_PER << 5) | lid] = period;
    487493
    488     // enable the PTI in local XCU controller
     494    // enable PTI in local XCU controller
    489495    base[(XCU_MSK_PTI_ENABLE << 5) | lid] = 1 << lid;
     496}
     497
     498////////////////////////////
     499void soclib_pic_enable_ipi()
     500{
     501    // calling core local index
     502    lid_t  lid = CURRENT_CORE->lid;
     503
     504    // get XCU segment base
     505    uint32_t * base = soclib_pic_xcu_base();
     506
     507    // enable WTI in local XCU controller
     508    base[(XCU_MSK_WTI_ENABLE << 5) | lid] = 1 << lid;
    490509}
    491510
  • trunk/hal/tsar_mips32/drivers/soclib_pic.h

    r238 r279  
    228228
    229229/******************************************************************************************
    230  * This function activates the TICK timer for the calling core.
     230 * This function activates the PTI timer for the calling core.
    231231 * The <period> argument define the number of cycles between IRQs.
    232232 ******************************************************************************************
     
    234234 *****************************************************************************************/
    235235void soclib_pic_enable_timer( uint32_t period );
     236
     237/******************************************************************************************
     238 * This function activates the WTI[lid] in the local cluster, wherehe lid is the calling
     239 * core local index.
     240 *****************************************************************************************/
     241void soclib_pic_enable_ipi();
    236242
    237243/******************************************************************************************
     
    279285
    280286/******************************************************************************************
    281  * This function acknowledge a PTI IRQ generated by the local XCU for a core
    282  * identified by the <lid> argument.
    283  *****************************************************************************************/
    284 uint32_t soclib_pic_ack_timer( lid_t lid );
    285 
    286 /******************************************************************************************
    287287 * This function returns in the <hwi_status>, <wti_status>, <pti_status> buffers
    288288 * the local XCU status for a given core identidied by the <lid> argument.
  • trunk/hal/tsar_mips32/drivers/soclib_tty.c

    r77 r279  
    5454
    5555    // get command type and extended pointer on TXT device
    56     uint32_t type   =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.txt.type ) );
    57     xptr_t   dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.txt.dev_xp ) );
     56    uint32_t type   =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.type ) );
     57    xptr_t   dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
    5858
    5959    // get TXT device cluster and local pointer
     
    103103
    104104        // get source buffer extended pointer & bytes count
    105         uint32_t count  = hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.txt.count ) );
    106         xptr_t   buf_xp = hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.txt.buf_xp ) );
     105        uint32_t count  = hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.count ) );
     106        xptr_t   buf_xp = hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.buf_xp ) );
    107107
    108108        // loop on characters
     
    127127        }
    128128    }
    129 }
     129}  // end soclib_tty_cmd()
     130
    130131
    131132/////////////////////////////////////////////////////////////////
     
    148149
    149150    // get command arguments
    150     type    = hal_remote_lw ( XPTR( client_cxy , &client_ptr->command.txt.type   ) );
    151     count   = hal_remote_lw ( XPTR( client_cxy , &client_ptr->command.txt.count  ) );
    152     buf_xp  = hal_remote_lwd( XPTR( client_cxy , &client_ptr->command.txt.buf_xp ) );
     151    type    = hal_remote_lw ( XPTR( client_cxy , &client_ptr->txt_cmd.type   ) );
     152    count   = hal_remote_lw ( XPTR( client_cxy , &client_ptr->txt_cmd.count  ) );
     153    buf_xp  = hal_remote_lwd( XPTR( client_cxy , &client_ptr->txt_cmd.buf_xp ) );
    153154
    154155    // get SOCLIB_TTY peripheral cluster and local pointer
     
    210211            else         // TTY_TX full => update command arguments and exit ISR for retry
    211212            {
    212                 hal_remote_sw ( XPTR( client_cxy , &client_ptr->command.txt.count ), count-i );
    213                 hal_remote_swd( XPTR( client_cxy , &client_ptr->command.txt.buf_xp ), buf_xp+i );
     213                hal_remote_sw ( XPTR( client_cxy , &client_ptr->txt_cmd.count ), count-i );
     214                hal_remote_swd( XPTR( client_cxy , &client_ptr->txt_cmd.buf_xp ), buf_xp+i );
    214215                return;
    215216            }
     
    223224
    224225    // set I/O operation status in command
    225     hal_remote_sw( XPTR( client_cxy , &client_ptr->command.txt.error ) , 0 );
     226    hal_remote_sw( XPTR( client_cxy , &client_ptr->txt_cmd.error ) , 0 );
    226227
    227228    // unblock server thread
     
    230231    // unblock client thread
    231232    thread_unblock( client_xp , THREAD_BLOCKED_IO );
    232 }
    233 
     233
     234}  // end soclib_tty_isr()
     235
  • trunk/hal/tsar_mips32/kernel.ld

    r63 r279  
    55
    66/* Define the kernel code base address */
    7 kernel_base = 0x4000;
    87
    9 /*
    10  * Set the entry point of the boot-loader (e_entry field in the "boot.elf"
    11  * file header)
    12  */
     8seg_kcode_base = 0x00004000;
     9seg_kgiet_base = 0x80000000;
     10
     11/* Set the entry point (e_entry field in the "kernel.elf" file header) */
    1312
    1413ENTRY(kernel_init)
    1514
    16 /*
    17  * Describe how to group the sections
    18  */
     15/* Describe how to group the sections */
     16
    1917SECTIONS
    2018{
    21         . = kernel_base;
     19        . = seg_kcode_base;
    2220        seg_kcode :
    2321        {
     
    3533                *(.data*)
    3634        }
     35
     36    . = seg_kgiet_base;
     37    seg_kgiet :
     38    {
     39                *(.kgiet)
     40    }
    3741}
Note: See TracChangeset for help on using the changeset viewer.