Ignore:
Timestamp:
Oct 4, 2014, 3:21:56 PM (10 years ago)
Author:
alain
Message:

Introducing fixed format (X_WIDTH / YWIDTH / P_WIDTH) for processor index.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_common/utils.c

    r408 r430  
    2020
    2121// This global variable is allocated in the boot.c file or in kernel_init.c file
    22 extern static_scheduler_t* _schedulers[NB_PROCS_MAX<<(X_WIDTH+Y_WIDTH)];
     22extern static_scheduler_t* _schedulers[X_SIZE][Y_SIZE][NB_PROCS_MAX];
    2323
    2424///////////////////////////////////////////////////////////////////////////////////
    … …  
    7272    asm volatile ( "mfc0     %0,     $15, 1  \n"
    7373                   :"=r" (ret) );
    74     return (ret & 0x3FF);
     74    return (ret & 0xFFF);
    7575}
    7676////////////////////////////
    … …  
    173173
    174174////////////////////////////////////////////////////////////////////////////
    175 // This function makes a physical read access to a 32 bits word in memory,
    176 // after a temporary DTLB de-activation and paddr extension.
    177 ////////////////////////////////////////////////////////////////////////////
    178175unsigned int _physical_read( unsigned long long paddr )
    179176{
    … …  
    202199}
    203200////////////////////////////////////////////////////////////////////////////
    204 // This function makes a physical write access to a 32 bits word in memory,
    205 // after a temporary DTLB de-activation and paddr extension.
    206 ////////////////////////////////////////////////////////////////////////////
    207201void _physical_write( unsigned long long paddr,
    208                                unsigned int       value )
     202                      unsigned int       value )
    209203{
    210204    unsigned int lsb = (unsigned int)paddr;
    … …  
    212206    unsigned int sr;
    213207
    214     _it_disable(&sr);
     208   _it_disable(&sr);
    215209
    216210    asm volatile( "mfc2   $2,     $1                 \n"     /* $2 <= MMU_MODE   */
    … …  
    232226
    233227////////////////////////////////////////////////////////////////////////////
    234 // This function makes a physical read access to a 64 bits word in memory,
    235 // after a temporary DTLB de-activation and paddr extension.
    236 ////////////////////////////////////////////////////////////////////////////
    237228unsigned long long _physical_read_ull( unsigned long long paddr )
    238229{
    … …  
    266257
    267258////////////////////////////////////////////////////////////////////////////
    268 // This function makes a physical write access to a 64 bits word in memory,
    269 // after a temporary DTLB de-activation and paddr extension.
    270 ////////////////////////////////////////////////////////////////////////////
    271259void _physical_write_ull( unsigned long long paddr,
    272260                          unsigned long long value )
    … …  
    304292// multiple of 4 bytes.
    305293///////////////////////////////////////////////////////////////////////////////////
    306 void _physical_memcpy( unsigned long long dst_paddr,  // dest buffer paddr
     294void _physical_memcpy( unsigned long long dst_paddr,  // destination buffer paddr
    307295                       unsigned long long src_paddr,  // source buffer paddr
    308296                       unsigned int size )            // bytes
    … …  
    352340
    353341    _it_restore(&sr);
    354 }
    355 
    356 ///////////////////////////////////////////////////////////////////////////////////
    357 // This function is used by several drivers (_xxx_set_register() function)
    358 // If the MMU is not activated, the virtual address is extended using
    359 // X_IO and Y_IO to reach the cluster_io.
     342} // end _physical_memcpy()
     343
     344/////////////////////////////////////////////////////////////////////////////////
     345void _physical_memset( unsigned long long paddr,     // destination buffer paddr
     346                       unsigned int       size,      // bytes
     347                       unsigned int       data )     // written value
     348{
     349    // check alignment constraints
     350    if ( (paddr & 3) || (size & 3) )
     351    {
     352        _printf("\n[GIET ERROR] in _physical_memset() : buffer unaligned\n");
     353        _exit();
     354    }
     355
     356    unsigned int lsb  = (unsigned int)paddr;
     357    unsigned int msb  = (unsigned int)(paddr >> 32);
     358    unsigned int sr;
     359
     360    _it_disable(&sr);
     361
     362    asm volatile( "move   $4,     %0                 \n"     /* $4 < lsb               */
     363                  "move   $5,     %1                 \n"     /* $5 < msb               */
     364                  "move   $6,     %2                 \n"     /* $6 < size              */
     365                  "move   $7,     %3                 \n"     /* $7 < data              */
     366
     367                  "mfc2   $2,     $1                 \n"     /* $2 <= current MMU_MODE */
     368                  "andi   $3,     $2,        0xb     \n"     /* $3 <= new MMU_MODE     */
     369                  "mtc2   $3,     $1                 \n"     /* DTLB off               */   
     370                  "mtc2   $5,     $24                \n"     /* PADDR_EXT <= msb       */   
     371         
     372                  "ph_memset_loop:                   \n"
     373                  "sw     $7,     0($4)              \n"     /* data <= *src_paddr     */
     374                  "addi   $4,     $4,        4       \n"     /* iter = iter - 1        */
     375                  "bne    $4,     $6, ph_memcpy_loop \n"
     376                  "nop                               \n"
     377
     378                  "mtc2   $0,     $24                \n"     /* PADDR_EXT <= 0         */   
     379                  "mtc2   $2,     $1                 \n"     /* restore MMU_MODE       */
     380                  : "=r" (data)
     381                  : "r" (lsb), "r" (msb), "r" (size), "r"(data)
     382                  : "$2", "$3", "$4", "$5", "$6", "$7" );
     383
     384    _it_restore(&sr);
     385}  // _pysical_memset()
     386
    360387///////////////////////////////////////////////////////////////////////////////////
    361388void _io_extended_write( unsigned int*  vaddr,
    … …  
    378405
    379406///////////////////////////////////////////////////////////////////////////////////
    380 // This function is used by all drivers (_xxx_get_register() function)
    381 // If the MMU is not activated, the virtual address is extended using
    382 // X_IO and Y_IO to reach the cluster_io.
    383 ///////////////////////////////////////////////////////////////////////////////////
    384407unsigned int _io_extended_read( unsigned int*  vaddr )
    385408{
    … …  
    402425///////////////////////////////////////////////////////////////////////////////////
    403426
    404 ///////////////////////////////////////////////////////////////////////////////////
    405 // Takes a lock with a blocking ll/sc atomic access.
    406 // When the cache coherence is granted by the hardware,
    407 // the first read is a standard (cacheable) lw, as the local copy
    408 // can be polled when the lock is already taken by another task, reducing
    409 // trafic on the interconnect. When the lock is released by the owner task,
    410 // the local copy is updated or invalidated by the coherence protocol.
    411 // If there is no hardware cache coherence a random delay is introduced
    412 // betwween two successive retry.
    413427///////////////////////////////////////////////////////////////////////////////////
    414428void _get_lock(giet_lock_t* lock)
    … …  
    460474}
    461475
    462 ///////////////////////////////////////////////////////////////////////////////////
    463 // Release a previouly taken lock.
    464476///////////////////////////////////////////////////////////////////////////////////
    465477void _release_lock(giet_lock_t* lock)
    … …  
    711723    {
    712724        unsigned int procid     = _get_procid();
    713         unsigned int lpid       = procid % NB_PROCS_MAX;
    714         unsigned int cluster_xy = procid / NB_PROCS_MAX;
    715         unsigned int x          = cluster_xy >> Y_WIDTH;
    716         unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
     725        unsigned int x          = (procid >> (Y_WIDTH + P_WIDTH)) & ((1<<X_WIDTH)-1);
     726        unsigned int y          = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
     727        unsigned int lpid       = procid & ((1<<P_WIDTH)-1);
    717728
    718729        _puts("\n\n[GIET ERROR] in _printf() for processor[");
    … …  
    744755
    745756
    746 //////////////////////////////////////////////////////////////////////////////
     757////////////////////////////////////////////////////////////////////////////////////
    747758//           Scheduler and tasks context access functions
    748 //////////////////////////////////////////////////////////////////////////////
    749 
    750 //////////////////////////////////////////////////////////////////////////////
    751 // Returns index of the currently running task from the processor scheduler.
    752 //////////////////////////////////////////////////////////////////////////////
     759////////////////////////////////////////////////////////////////////////////////////
     760
     761
     762////////////////////////////////////////////////////////////////////////////////////
    753763unsigned int _get_current_task_id()
    754764{
    … …  
    757767}
    758768////////////////////////////////////////////////////////////////////////////////////
    759 // This function returns the content of a context slot
    760 // for a task identified by the ltid argument (local task index),
    761 // and the gpid argument (global processor index)
    762 ////////////////////////////////////////////////////////////////////////////////////
    763 unsigned int _get_task_slot( unsigned int gpid,
     769unsigned int _get_task_slot( unsigned int x,
     770                             unsigned int y,
     771                             unsigned int p,
    764772                             unsigned int ltid,
    765773                             unsigned int slot )
    766774{
    767     static_scheduler_t* psched  = (static_scheduler_t*)_schedulers[gpid];
     775    static_scheduler_t* psched  = (static_scheduler_t*)_schedulers[x][y][p];
    768776    return psched->context[ltid][slot];
    769777}
    770778////////////////////////////////////////////////////////////////////////////////////
    771 // This function updates the content of a context slot
    772 // for any task identified by the ltid argument (local task index),
    773 // and the gpid argument (global processor index)
    774 ////////////////////////////////////////////////////////////////////////////////////
    775 void _set_task_slot( unsigned int gpid,
     779void _set_task_slot( unsigned int x,
     780                     unsigned int y,
     781                     unsigned int p,
    776782                     unsigned int ltid,
    777783                     unsigned int slot,
    778784                     unsigned int value )
    779785{
    780     static_scheduler_t* psched  = (static_scheduler_t*)_schedulers[gpid];
     786    static_scheduler_t* psched  = (static_scheduler_t*)_schedulers[x][y][p];
    781787    psched->context[ltid][slot] = value;
    782788}
    783 ////////////////////////////////////////////////////////////////////////////////////
    784 // This function returns the content of a context slot
    785 // for the running task (defined by the scheduler current field).
    786789////////////////////////////////////////////////////////////////////////////////////
    787790unsigned int _get_context_slot( unsigned int slot )
    … …  
    791794    return psched->context[task_id][slot];
    792795}
    793 ////////////////////////////////////////////////////////////////////////////////////
    794 // This function updates the content of a context slot for the running task.
    795796////////////////////////////////////////////////////////////////////////////////////
    796797void _set_context_slot( unsigned int slot,
    … …  
    968969{
    969970    unsigned int procid     = _get_procid();
    970     unsigned int lpid       = procid % NB_PROCS_MAX;
    971     unsigned int cluster_xy = procid / NB_PROCS_MAX;
    972     unsigned int x          = cluster_xy >> Y_WIDTH;
    973     unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
     971    unsigned int x          = (procid >> (Y_WIDTH + P_WIDTH)) & ((1<<X_WIDTH)-1);
     972    unsigned int y          = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
     973    unsigned int lpid       = procid & ((1<<P_WIDTH)-1);
    974974
    975975
Note: See TracChangeset for help on using the changeset viewer.