Changeset 438 for soft/giet_vm


Ignore:
Timestamp:
Nov 3, 2014, 10:54:50 AM (10 years ago)
Author:
alain
Message:

Inroducing support in the stdio for dynamic allocation of peripherals
in the stdio library.

Location:
soft/giet_vm/giet_libs
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_libs/stdio.c

    r431 r438  
    1414////////////////////////////////////////////////////////////////////////////////////
    1515
    16 /////////////////
     16////////////////////////////////////////////
    1717void giet_proc_xyp( unsigned int* cluster_x,
    1818                    unsigned int* cluster_y,
    1919                    unsigned int* lpid )
    2020{
    21     sys_call( SYSCALL_PROCID,
     21    sys_call( SYSCALL_PROC_XYP,
    2222              (unsigned int)cluster_x,
    2323              (unsigned int)cluster_y,
    … …  
    2626}
    2727
    28 ////////////////////
    29 int giet_proctime()
    30 {
    31     return sys_call( SYSCALL_PROCTIME,
    32                      0, 0, 0, 0 );
    33 }
    34 
    35 ///////////////
    36 int giet_rand()
    37 {
    38     unsigned int x = sys_call(SYSCALL_PROCTIME,
    39                               0, 0, 0, 0);
     28////////////////////////////
     29unsigned int giet_proctime()
     30{
     31    return (unsigned int)sys_call( SYSCALL_PROC_TIME,
     32                                   0, 0, 0, 0 );
     33}
     34
     35////////////////////////
     36unsigned int giet_rand()
     37{
     38    unsigned int x = (unsigned int)sys_call( SYSCALL_PROC_TIME,
     39                                             0, 0, 0, 0);
    4040    if ((x & 0xF) > 7)
    4141    {
    … …  
    4747    }
    4848}
     49
     50//////////////////////////////////////////////////////////////////////////////////
     51///////////////////// Task context  system calls /////////////////////////////////
     52//////////////////////////////////////////////////////////////////////////////////
     53
     54////////////////////////////////
     55unsigned int giet_proc_task_id()
     56{
     57    return (unsigned int)sys_call( SYSCALL_LOCAL_TASK_ID,
     58                                   0, 0, 0, 0 );
     59}
     60
     61//////////////////////////////////
     62unsigned int giet_global_task_id()
     63{
     64    return (unsigned int)sys_call( SYSCALL_GLOBAL_TASK_ID,
     65                                   0, 0, 0, 0 );
     66}
     67
     68/////////////////////////////
     69unsigned int giet_thread_id()
     70{
     71    return (unsigned int)sys_call( SYSCALL_THREAD_ID,
     72                                   0, 0, 0, 0 );
     73}
     74
    4975
    5076////////////////////////////////////////////////////////////////////////////////////
    … …  
    5278////////////////////////////////////////////////////////////////////////////////////
    5379
    54 ///////////////////////////////////////////////////////////////////////
    55 static int __printf( char* format, unsigned int channel, va_list* args)
    56 {
    57     int ret;                    // return value from the syscalls
     80/////////////////////
     81void giet_tty_alloc()
     82{
     83    sys_call( SYSCALL_TTY_ALLOC, 0, 0 ,0 ,0 );
     84}
     85
     86////////////////////////////////////////////////////////////////////////
     87static  int __printf( char* format, unsigned int channel, va_list* args)
     88{
     89    int ret;                    // return value from the syscall
    5890
    5991printf_text:
    … …  
    420452
    421453///////////////////////
    422 void giet_timer_start()
    423 {
    424     if ( sys_call( SYSCALL_TIMER_START, 0, 0, 0, 0 ) )
    425        giet_exit("error in giet_timer_start()");
     454void giet_timer_alloc()
     455{
     456    if ( sys_call( SYSCALL_TIM_ALLOC,
     457                   0, 0, 0, 0 ) ) giet_exit("error in giet_timer_alloc()");
     458}
     459
     460////////////////////////////////////////////
     461void giet_timer_start( unsigned int period )
     462{
     463    if ( sys_call( SYSCALL_TIM_START,
     464                   period,
     465                   0, 0, 0 ) ) giet_exit("error in giet_timer_start()");
    426466}
    427467
    … …  
    429469void giet_timer_stop()
    430470{
    431     if ( sys_call( SYSCALL_TIMER_STOP, 0, 0, 0, 0 ) )
    432         giet_exit("error in giet_timer_stop()");
     471    if ( sys_call( SYSCALL_TIM_STOP,
     472                   0, 0, 0, 0 ) ) giet_exit("error in giet_timer_stop()");
    433473}
    434474
    … …  
    438478//////////////////////////////////////////////////////////////////////////////////
    439479
    440 ////////////////////////////////////////////
    441 void giet_fb_sync_write( unsigned int offset,
    442                         void *       buffer,
    443                         unsigned int length )
    444 {
    445     if ( sys_call( SYSCALL_FB_SYNC_WRITE,
     480/////////////////////////
     481void giet_fbf_cma_alloc()
     482{
     483    if ( sys_call( SYSCALL_FBF_CMA_ALLOC,
     484                   0, 0, 0, 0 ) )    giet_exit("error in giet_fbf_cma_alloc()");
     485}
     486
     487///////////////////////////////////////////
     488void giet_fbf_cma_start( void *       buf0,
     489                         void *       buf1,
     490                         unsigned int length )
     491{
     492    if ( sys_call( SYSCALL_FBF_CMA_START,
     493                   (unsigned int)buf0,
     494                   (unsigned int)buf1,
     495                   length,
     496                   0 ) )   giet_exit("error in giet_fbf_cma_start()");
     497}
     498
     499////////////////////////////////////////////////
     500void giet_fbf_cma_display( unsigned int buffer )
     501{
     502    if ( sys_call( SYSCALL_FBF_CMA_DISPLAY,
     503                   buffer,
     504                   0, 0, 0 ) )   giet_exit("error in giet_fbf_cma_display()");
     505}
     506
     507////////////////////////
     508void giet_fbf_cma_stop()
     509{
     510    if ( sys_call( SYSCALL_FBF_CMA_STOP,
     511                   0, 0, 0, 0 ) )    giet_exit("error in giet_fbf_cma_stop()");
     512}
     513
     514//////////////////////////////////////////////
     515void giet_fbf_sync_write( unsigned int offset,
     516                          void *       buffer,
     517                          unsigned int length )
     518{
     519    if ( sys_call( SYSCALL_FBF_SYNC_WRITE,
    446520                   offset,
    447521                   (unsigned int)buffer,
    448522                   length,
    449                    0 ) )  giet_exit("error in giet_fb_sync_write()");
    450 }
    451 
    452 ///////////////////////////////////////////
    453 void giet_fb_sync_read( unsigned int offset,
    454                         void *       buffer,
    455                         unsigned int length )
    456 {
    457     if ( sys_call( SYSCALL_FB_SYNC_READ,
     523                   0 ) )  giet_exit("error in giet_fbf_sync_write()");
     524}
     525
     526/////////////////////////////////////////////
     527void giet_fbf_sync_read( unsigned int offset,
     528                         void *       buffer,
     529                         unsigned int length )
     530{
     531    if ( sys_call( SYSCALL_FBF_SYNC_READ,
    458532                   offset,
    459533                   (unsigned int)buffer,
    460534                   length,
    461                    0 ) )   giet_exit("error in giet_fb_sync_read()");
    462 }
    463 
    464 /////////////////////////////////////////
    465 void giet_fb_cma_init( void *       buf0,
    466                        void *       buf1,
    467                        unsigned int length )
    468 {
    469     if ( sys_call( SYSCALL_FB_CMA_INIT,
    470                    (unsigned int)buf0,
    471                    (unsigned int)buf1,
    472                    length,
    473                    0 ) )   giet_exit("error in giet_fb_cma_init()");
    474 }
    475 
    476 ///////////////////////////////////////////////
    477 void giet_fb_cma_write( unsigned int buffer_id )
    478 {
    479     if ( sys_call( SYSCALL_FB_CMA_WRITE,
    480                    buffer_id,
    481                    0, 0, 0 ) )   giet_exit("error in giet_fb_cma_write()");
    482 }
    483 
    484 ////////////////////////
    485 void giet_fb_cma_stop()
    486 {
    487     if ( sys_call( SYSCALL_FB_CMA_STOP,
    488                    0, 0, 0, 0 ) )    giet_exit("error in giet_fb_cma_stop()");
     535                   0 ) )   giet_exit("error in giet_fbf_sync_read()");
    489536}
    490537
    … …  
    494541//////////////////////////////////////////////////////////////////////////////////
    495542
    496 /////////////////////////
    497 void giet_nic_cma_start()
    498 {
    499     if ( sys_call( SYSCALL_NIC_CMA_START, 0, 0, 0, 0 ) ) 
    500        giet_exit("error in giet_nic_cma_start()");
    501 }
    502 
    503 /////////////////////////
    504 void giet_nic_cma_stop()
    505 {
    506     if ( sys_call( SYSCALL_NIC_CMA_STOP, 0, 0, 0, 0 ) ) 
    507         giet_exit("error in giet_nic_cma_stop()");
     543/////////////////////
     544void giet_nic_alloc()
     545{
     546    if ( sys_call( SYSCALL_NIC_ALLOC,
     547                   0, 0, 0, 0 ) ) giet_exit("error in giet_nic_alloc()");
     548}
     549
     550///////////////////////////////////////
     551void giet_nic_sync_send( void* buffer )
     552{
     553    if ( sys_call( SYSCALL_NIC_SYNC_SEND,
     554                   (unsigned int)buffer,
     555                   0, 0, 0 ) )  giet_exit("error in giet_nic_sync_send()");
     556}
     557
     558//////////////////////////////////////////
     559void giet_nic_sync_receive( void* buffer )
     560{
     561    if ( sys_call( SYSCALL_NIC_SYNC_RECEIVE,
     562                   (unsigned int)buffer,
     563                   0, 0, 0 ) )  giet_exit("error in giet_nic_sync_receive()");
    508564}
    509565
    … …  
    595651
    596652
    597 //////////////////////////////////////////////////////////////////////////////////
    598 ///////////////////// Task context  system calls /////////////////////////////////
    599 //////////////////////////////////////////////////////////////////////////////////
    600 
    601 ///////////////////////
    602 int giet_proc_task_id()
    603 {
    604     return sys_call( SYSCALL_LOCAL_TASK_ID,
    605                      0, 0, 0, 0 );
    606 }
    607 
    608 /////////////////////////
    609 int giet_global_task_id()
    610 {
    611     return sys_call( SYSCALL_GLOBAL_TASK_ID,
    612                      0, 0, 0, 0 );
    613 }
    614 
    615 ////////////////////
    616 int giet_thread_id()
    617 {
    618     return sys_call( SYSCALL_THREAD_ID,
    619                      0, 0, 0, 0 );
    620 }
    621653
    622654
    … …  
    645677    sys_call( SYSCALL_CTX_SWITCH,
    646678              0, 0, 0, 0 );
    647 }
    648 
    649 ////////////////////////////////////////////////////
    650 void giet_vobj_get_vbase( char*         vspace_name,
    651                           char*         vobj_name,
    652                           unsigned int* vobj_vaddr )
    653 {
    654     if ( sys_call( SYSCALL_VOBJ_GET_VBASE,
    655                    (unsigned int) vspace_name,
    656                    (unsigned int) vobj_name,
    657                    (unsigned int) vobj_vaddr,
    658                    0 ) )  giet_exit("ERROR in giet_vobj_get_vbase()");
    659679}
    660680
    … …  
    667687                   (unsigned int) buffer,
    668688                   0, 0) )  giet_exit("ERROR in giet_proc_number()");
     689}
     690
     691////////////////////////////////////////////////////
     692void giet_vobj_get_vbase( char*         vspace_name,
     693                          char*         vobj_name,
     694                          unsigned int* vbase )
     695{
     696    if ( sys_call( SYSCALL_VOBJ_GET_VBASE,
     697                   (unsigned int) vspace_name,
     698                   (unsigned int) vobj_name,
     699                   (unsigned int) vbase,
     700                   0 ) )  giet_exit("ERROR in giet_vobj_get_vbase()");
     701}
     702
     703////////////////////////////////////////////////////
     704void giet_vobj_get_length( char*         vspace_name,
     705                           char*         vobj_name,
     706                           unsigned int* length )
     707{
     708    if ( sys_call( SYSCALL_VOBJ_GET_LENGTH,
     709                   (unsigned int) vspace_name,
     710                   (unsigned int) vobj_name,
     711                   (unsigned int) length,
     712                   0 ) )  giet_exit("ERROR in giet_vobj_get_length()");
    669713}
    670714

  • soft/giet_vm/giet_libs/stdio.h

    r431 r438  
    1616// the _syscall_vector defined in file sys_handler.c
    1717
    18 #define SYSCALL_PROCID            0x00
    19 #define SYSCALL_PROCTIME          0x01
     18#define SYSCALL_PROC_XYP          0x00
     19#define SYSCALL_PROC_TIME         0x01
    2020#define SYSCALL_TTY_WRITE         0x02
    2121#define SYSCALL_TTY_READ          0x03
    22 #define SYSCALL_TIMER_START       0x04
    23 #define SYSCALL_TIMER_STOP        0x05
    24 #define SYSCALL_TTY_GET_LOCK      0x06
    25 #define SYSCALL_TTY_RELEASE_LOCK  0x07
    26 #define SYSCALL_HEAP_INFO         0x08
    27 #define SYSCALL_LOCAL_TASK_ID     0x09
    28 #define SYSCALL_GLOBAL_TASK_ID    0x0A
    29 #define SYSCALL_FB_CMA_INIT       0x0B
    30 #define SYSCALL_FB_CMA_WRITE      0x0C
    31 #define SYSCALL_FB_CMA_STOP       0x0D
     22#define SYSCALL_TTY_ALLOC         0x04
     23#define SYSCALL_TTY_GET_LOCK      0x05
     24#define SYSCALL_TTY_RELEASE_LOCK  0x06
     25#define SYSCALL_HEAP_INFO         0x07
     26#define SYSCALL_LOCAL_TASK_ID     0x08
     27#define SYSCALL_GLOBAL_TASK_ID    0x09
     28#define SYSCALL_FBF_CMA_ALLOC     0x0A
     29#define SYSCALL_FBF_CMA_START     0x0B
     30#define SYSCALL_FBF_CMA_DISPLAY   0x0C
     31#define SYSCALL_FBF_CMA_STOP      0x0D
    3232#define SYSCALL_EXIT              0x0E
    3333#define SYSCALL_PROC_NUMBER       0x0F
    3434
    35 #define SYSCALL_FB_SYNC_WRITE     0x10
    36 #define SYSCALL_FB_SYNC_READ      0x11
     35#define SYSCALL_FBF_SYNC_WRITE    0x10
     36#define SYSCALL_FBF_SYNC_READ     0x11
    3737#define SYSCALL_THREAD_ID         0x12
    38 #define SYSCALL_FREE_13           0x13
    39 #define SYSCALL_FREE_14           0x14
    40 #define SYSCALL_FREE_15           0x15
    41 #define SYSCALL_FREE_16           0x16
    42 #define SYSCALL_FREE_17           0x17
    43 #define SYSCALL_FREE_18           0x18
     38//                                0x13
     39#define SYSCALL_TIM_ALLOC         0x14
     40#define SYSCALL_TIM_START         0x15
     41#define SYSCALL_TIM_STOP          0x16
     42//                                0x17
     43//                                0x18
    4444#define SYSCALL_CTX_SWITCH        0x19
    4545#define SYSCALL_VOBJ_GET_VBASE    0x1A
    46 #define SYSCALL_GET_XY            0x1B
    47 #define SYSCALL_NIC_CMA_START     0x1C
    48 #define SYSCALL_NIC_CMA_STOP      0x1D
    49 #define SYSCALL_NIC_SYNC_READ     0x1E
    50 #define SYSCALL_NIC_SYNC_WRITE    0x1F
     46#define SYSCALL_VOBJ_GET_LENGTH   0x1B
     47#define SYSCALL_GET_XY            0x1C
     48#define SYSCALL_NIC_ALLOC         0x1D
     49#define SYSCALL_NIC_SYNC_SEND     0x1E
     50#define SYSCALL_NIC_SYNC_RECEIVE  0x1F
    5151
    5252#define SYSCALL_FAT_OPEN          0x20
    … …  
    5656#define SYSCALL_FAT_FSTAT         0x24
    5757#define SYSCALL_FAT_CLOSE         0x25
     58//                                0x26
     59//                                0x27
     60//                                0x28
     61//                                0x29
     62//                                0x2A
     63//                                0x2B
     64//                                0x2C
     65//                                0x2D
     66//                                0x2E
     67//                                0x2F
    5868
    5969//////////////////////////////////////////////////////////////////////////////////
    … …  
    6777// It writes the system call arguments in the proper registers,
    6878// and tells GCC what has been modified by system call execution.
     79// Returns -1 to signal an error.
    6980//////////////////////////////////////////////////////////////////////////////////
    7081static inline int sys_call( int call_no,
    … …  
    110121
    111122//////////////////////////////////////////////////////////////////////////
    112 //////////////////////////////////////////////////////////////////////////
    113123//               MIPS32 related system calls
    114124//////////////////////////////////////////////////////////////////////////
    115 //////////////////////////////////////////////////////////////////////////
    116 
    117 //////////////////////////////////////////////////////////////////////////
    118 // This function returns the processor (x,y,lpid) identifier:
    119 // (x,y) are the cluster coordinates / lpid is the local processor index.
     125
    120126//////////////////////////////////////////////////////////////////////////
    121127extern void giet_proc_xyp( unsigned int* cluster_x,
    … …  
    123129                           unsigned int* lpid );
    124130
    125 //////////////////////////////////////////////////////////////////////////
    126 // This function returns the local processor time.
    127 //////////////////////////////////////////////////////////////////////////
    128 extern int giet_proctime();
    129 
    130 //////////////////////////////////////////////////////////////////////////
    131 // This function returns a pseudo-random value derived from the processor
    132 // cycle count. This value is comprised between 0 & 65535.
    133 /////////////////////////////////////////////////////////////////////////
    134 extern int giet_rand();
    135 
    136 //////////////////////////////////////////////////////////////////////////
     131extern unsigned int giet_proctime();
     132
     133extern unsigned int giet_rand();
     134
     135//////////////////////////////////////////////////////////////////////////
     136//                    Task context system calls
     137//////////////////////////////////////////////////////////////////////////
     138
     139extern unsigned int giet_proc_task_id();
     140
     141extern unsigned int giet_global_task_id();
     142
     143extern unsigned int giet_thread_id();
     144
    137145//////////////////////////////////////////////////////////////////////////
    138146//             TTY device related system calls
    139147//////////////////////////////////////////////////////////////////////////
    140 //////////////////////////////////////////////////////////////////////////
    141 
    142 //////////////////////////////////////////////////////////////////////////
    143 // This function is a modified version of the mutek_printf().
    144 // It uses a private terminal allocated to the calling task in the boot.
    145 // ("use_tty" argument in xml mapping), and does not take the TTY lock.
    146 // It calls several times the _tty_write system function.
    147 // Only a limited number of formats are supported:
    148 //   - %d : signed decimal
    149 //   - %u : unsigned decimal
    150 //   - %x : 32 bits hexadecimal
    151 //   - %l : 64 bits hexadecimal
    152 //   - %c : char
    153 //   - %s : string
    154 // In case or error returned by syscall, it makes a giet_exit().
    155 //////////////////////////////////////////////////////////////////////////
     148
     149extern void giet_tty_alloc();
     150
    156151extern void giet_tty_printf( char* format, ... );
    157152
    158 //////////////////////////////////////////////////////////////////////////
    159 // This function is a modified version of the mutek_printf().
    160 // It uses the kernel TTY0 as a shared terminal, and it takes the
    161 // TTY lock to get exclusive access during the format display.
    162 // It calls several times the _tty_write system function.
    163 // Only a limited number of formats are supported:
    164 //   - %d : signed decimal
    165 //   - %u : unsigned decimal
    166 //   - %x : 32 bits hexadecimal
    167 //   - %l : 64 bits hexadecimal
    168 //   - %c : char
    169 //   - %s : string
    170 // In case or error returned by syscall, it makes a giet_exit().
    171 //////////////////////////////////////////////////////////////////////////
    172153extern void giet_shr_printf( char* format, ... );
    173154
    174 //////////////////////////////////////////////////////////////////////////
    175 // This blocking function fetches a single character from the private
    176 // terminal allocated to the calling task in the boot.
    177 // It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer.
    178 // In case or error returned by syscall, it makes a giet_exit().
    179 //////////////////////////////////////////////////////////////////////////
    180155extern void giet_tty_getc( char* byte );
    181156
    182 //////////////////////////////////////////////////////////////////////////
    183 // This blocking function fetches a string from the private terminal
    184 // allocated to the calling task to a fixed length buffer.
    185 // The terminal index must be defined in the task context in the boot.
    186 // It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer.
    187 // - Up to (bufsize - 1) characters (including the non printable characters)
    188 //   are copied into buffer, and the string is completed by a NUL character.
    189 // - The <LF> character is interpreted, and the function close the string
    190 //   with a NUL character if <LF> is read.
    191 // - The <DEL> character is interpreted, and the corresponding character(s)
    192 //   are removed from the target buffer.
    193 // - It does not provide an echo.
    194 // In case or error returned by syscall, it makes a giet_exit().
    195 /////////////////////////////////////////////////////////////////////////
    196157extern void giet_tty_gets( char* buf, unsigned int bufsize );
    197158
    198 /////////////////////////////////////////////////////////////////////////
    199 // This blocking function fetches a string of decimal characters (most
    200 // significant digit first) to build a 32-bit unsigned integer from
    201 // the private TTY terminal allocated to the calling task.
    202 // The terminal index must be defined in the task context in the boot.
    203 // It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer.
    204 // - The non-blocking system function _tty_read is called several times,
    205 //   and the decimal characters are written in a 32 characters buffer
    206 //   until a <LF> character is read.
    207 // - It ignores non-decimal characters, and displays an echo
    208 //   system function) for each decimal character.
    209 // - The <DEL> character is interpreted, and previous characters can be cancelled.
    210 // - When the <LF> character is received, the string is converted to an
    211 //   unsigned int value. If the number of decimal digit is too large for the 32
    212 //   bits range, the zero value is returned.
    213 // In case or error returned by syscall, it makes a giet_exit().
    214 //////////////////////////////////////////////////////////////////////////
    215159extern void giet_tty_getw( unsigned int* val );
    216160
    217161//////////////////////////////////////////////////////////////////////////
    218 //////////////////////////////////////////////////////////////////////////
    219162//                TIMER device related system calls
    220163//////////////////////////////////////////////////////////////////////////
    221 //////////////////////////////////////////////////////////////////////////
    222 
    223 //////////////////////////////////////////////////////////////////////////
    224 // This function activates the private user timer allocated
    225 // to the calling task in the boot phase.
    226 // In case or error returned by syscall, it makes a giet_exit().
    227 //////////////////////////////////////////////////////////////////////////
    228 extern void giet_timer_start();
    229 
    230 //////////////////////////////////////////////////////////////////////////
    231 // This function stops the private user timer allocated
    232 // to the calling task.
    233 // In case or error returned by syscall, it makes a giet_exit().
    234 //////////////////////////////////////////////////////////////////////////
     164
     165extern void giet_timer_alloc();
     166
     167extern void giet_timer_start( unsigned int period );
     168
    235169extern void giet_timer_stop();
    236170 
    237171//////////////////////////////////////////////////////////////////////////
    238 //////////////////////////////////////////////////////////////////////////
    239172//                Frame buffer device related system calls
    240173//////////////////////////////////////////////////////////////////////////
    241 //////////////////////////////////////////////////////////////////////////
    242 
    243 //////////////////////////////////////////////////////////////////////////
    244 // This blocking function use a memory copy strategy to transfer data
    245 // from the frame buffer device in kernel space to an user buffer.
    246 //     offset : offset (in bytes) in the frame buffer
    247 //     buffer : base address of the user buffer
    248 //     length : number of bytes to be transfered
    249 // In case or error returned by syscall, it makes a giet_exit().
    250 //////////////////////////////////////////////////////////////////////////
    251 extern void giet_fb_sync_read( unsigned int offset,
    252                                void*        buffer,
    253                                unsigned int length );
    254 
    255 //////////////////////////////////////////////////////////////////////////
    256 // This blocking function use a memory copy strategy to transfer data
    257 // from a user buffer to the frame buffer device in kernel space.
    258 //     offset : offset (in bytes) in the frame buffer
    259 //     buffer : base address of the memory buffer
    260 //     length : number of bytes to be transfered
    261 // In case or error returned by syscall, it makes a giet_exit().
    262 //////////////////////////////////////////////////////////////////////////
    263 extern void giet_fb_sync_write( unsigned int offset,
     174
     175extern void giet_fbf_cma_alloc();
     176
     177extern void giet_fbf_cma_start( void*        buf0,
     178                                void*        buf1,
     179                                unsigned int length );
     180
     181extern void giet_fbf_cma_display( unsigned int buffer );
     182
     183extern void giet_fbf_cma_stop();
     184
     185extern void giet_fbf_sync_read( unsigned int offset,
    264186                                void*        buffer,
    265187                                unsigned int length );
    266188
    267 //////////////////////////////////////////////////////////////////////////
    268 // This function initializes the two chbuf SRC an DST used by the CMA
    269 // controller and activates the CMA channel allocated to the calling task.
    270 // - buf0   : first user buffer virtual address
    271 // - buf1   : second user buffer virtual address
    272 // - length : buffer size (bytes)
    273 // In case or error returned by syscall, it makes a giet_exit().
    274 //////////////////////////////////////////////////////////////////////////
    275 extern void giet_fb_cma_init( void*        buf0,
    276                               void*        buf1,
    277                               unsigned int length );
    278 
    279 //////////////////////////////////////////////////////////////////////////
    280 // This function initializes the two chbuf SRC an DST used by the CMA
    281 // controller and activates the CMA channel allocated to the calling task.
    282 // - buf0   : first user buffer virtual address
    283 // - buf0   : second user buffer virtual address
    284 // - length : buffer size (bytes)
    285 // In case or error returned by syscall, it makes a giet_exit().
    286 //////////////////////////////////////////////////////////////////////////
    287 extern void giet_fb_cma_write( unsigned int buf_id );
    288 
    289 //////////////////////////////////////////////////////////////////////////
    290 // This function desactivates the CMA channel allocated to the task.
    291 // In case or error returned by syscall, it makes a giet_exit().
    292 //////////////////////////////////////////////////////////////////////////
    293 extern void giet_fb_cma_stop();
    294 
    295 //////////////////////////////////////////////////////////////////////////
     189extern void giet_fbf_sync_write( unsigned int offset,
     190                                 void*        buffer,
     191                                 unsigned int length );
     192
    296193//////////////////////////////////////////////////////////////////////////
    297194//                  NIC related system calls
    298195//////////////////////////////////////////////////////////////////////////
    299 //////////////////////////////////////////////////////////////////////////
    300 
    301 //////////////////////////////////////////////////////////////////////////
    302 // This function initializes the memory chbuf used by the CMA controller,
    303 // activates the NIC channel allocated to the calling task,
    304 // and activates the two CMA channels.
    305 // - tx     : RX channel if 0 / TX channel if non 0
    306 // - buf0   : first user buffer virtual address
    307 // - buf1   : second user buffer virtual address
    308 // - length : buffer size (bytes)
    309 // In case or error returned by syscall, it makes a giet_exit().
    310 //////////////////////////////////////////////////////////////////////////
    311 extern void giet_nic_cma_start();
    312 
    313 //////////////////////////////////////////////////////////////////////////
    314 // This function desactivates the NIC channel and the two CMA channels
    315 // allocated to the calling task.
    316 // In case or error returned by syscall, it makes a giet_exit().
    317 //////////////////////////////////////////////////////////////////////////
    318 extern void giet_nic_cma_stop();
    319 
    320 //////////////////////////////////////////////////////////////////////////
     196
     197extern void giet_nic_alloc();
     198
     199extern void giet_nic_sync_send( void* buffer);
     200
     201extern void giet_nic_sync_receive( void* buffer );
     202
    321203//////////////////////////////////////////////////////////////////////////
    322204//               FAT related system calls
    323205//////////////////////////////////////////////////////////////////////////
    324 //////////////////////////////////////////////////////////////////////////
    325 
    326 //////////////////////////////////////////////////////////////////////////
    327 // Open a file identified by a pathname, and contained in the system FAT.
    328 // The read/write flags are not supported yet: no effect.
    329 // Return -1 in case or error.
    330 //////////////////////////////////////////////////////////////////////////
     206
    331207extern int giet_fat_open(  const char*  pathname,
    332208                           unsigned int flags );
    333209
    334 ///////////////////////////////////////////////////////////////////////////////////
    335 // Read "count" sectors from a file identified by "fd", skipping "offset"
    336 // sectors in file, and writing into the user "buffer".
    337 // The user buffer base address shoulb be 64 bytes aligned.
    338 // In case or error returned by syscall, it makes a giet_exit().
    339 ///////////////////////////////////////////////////////////////////////////////////
    340210extern void giet_fat_read(  unsigned int fd,
    341211                            void*        buffer,
    … …  
    343213                            unsigned int offset );
    344214
    345 ///////////////////////////////////////////////////////////////////////////////////
    346 // Write "count" sectors into a file identified by "fd", skipping "offset"
    347 // sectors in file, and reading from the user "buffer".
    348 // The user buffer base address shoulb be 64 bytes aligned.
    349 // In case or error returned by syscall, it makes a giet_exit().
    350 ///////////////////////////////////////////////////////////////////////////////////
    351215extern void giet_fat_write( unsigned int fd,
    352216                            void*        buffer,
    … …  
    354218                            unsigned int offset );
    355219
    356 ///////////////////////////////////////////////////////////////////////////////////
    357 // Change the lseek file pointer value for a file identified by "fd".
    358 // In case or error returned by syscall, it makes a giet_exit().
    359 ///////////////////////////////////////////////////////////////////////////////////
    360220extern void giet_fat_lseek( unsigned int fd,
    361221                            unsigned int offset,
    362222                            unsigned int whence );
    363223
    364 ///////////////////////////////////////////////////////////////////////////////////
    365 // Returns general informations of a file identified by "fd".
    366 // (Only the file_size in sectors for this moment)
    367 ///////////////////////////////////////////////////////////////////////////////////
    368224extern void giet_fat_fstat( unsigned int fd );
    369225
    370 //////////////////////////////////////////////////////////////////////////
    371 // Close a file identified by "fd".
    372 //////////////////////////////////////////////////////////////////////////
    373226extern void giet_fat_close( unsigned int fd );
    374227
    375228//////////////////////////////////////////////////////////////////////////
    376 //////////////////////////////////////////////////////////////////////////
    377 //                    Task context system calls
    378 //////////////////////////////////////////////////////////////////////////
    379 //////////////////////////////////////////////////////////////////////////
    380 
    381 //////////////////////////////////////////////////////////////////////////
    382 // This functions returns the local task id.
    383 // If processor has n tasks the local task index is ranging from 0 to n-1
    384 //////////////////////////////////////////////////////////////////////////
    385 extern int giet_proc_task_id();
    386 
    387 //////////////////////////////////////////////////////////////////////////
    388 // This functions returns the global task id, (unique in the system).
    389 //////////////////////////////////////////////////////////////////////////
    390 extern int giet_global_task_id();
    391 
    392 //////////////////////////////////////////////////////////////////////////
    393 // This functions returns the thread index of the task in its vspace.
    394 //////////////////////////////////////////////////////////////////////////
    395 extern int giet_thread_id();
    396 
    397 //////////////////////////////////////////////////////////////////////////
    398 //////////////////////////////////////////////////////////////////////////
    399229//                    Miscelaneous system calls
    400230//////////////////////////////////////////////////////////////////////////
    401 //////////////////////////////////////////////////////////////////////////
    402 
    403 //////////////////////////////////////////////////////////////////////////
    404 // This function stops execution of the calling task with a TTY message,
    405 // the user task is descheduled and becomes not runable.
    406 // It does not consume processor cycles anymore.
    407 //////////////////////////////////////////////////////////////////////////
     231
    408232extern void giet_exit( char* string );
    409233
    410 //////////////////////////////////////////////////////////////////////////
    411 // This function uses the giet_exit() system call
    412 // and kill the calling task if the condition is false.
    413 //////////////////////////////////////////////////////////////////////////
    414234extern void giet_assert( unsigned int condition,
    415235                         char*        string );
    416236
    417 //////////////////////////////////////////////////////////////////////////
    418 // The user task calling this function is descheduled and
    419 // the processor is allocated to another task.
    420 //////////////////////////////////////////////////////////////////////////
    421237extern void giet_context_switch();
    422238
    423 //////////////////////////////////////////////////////////////////////////
    424 // This function writes in argument "vobj_vaddr" the virtual base address
    425 // of a vobj (defined in the mapping_info data structure), identified by
    426 // the two arguments "vspace_name" and "vobj_name".
    427 // In case or error returned by syscall, it makes a giet_exit().
    428 // ( vobj not defined or wrong vspace )
    429 //////////////////////////////////////////////////////////////////////////
     239extern void giet_procnumber( unsigned int cluster_xy,
     240                             unsigned int buffer );
     241
    430242extern void giet_vobj_get_vbase( char*         vspace_name,
    431243                                 char*         vobj_name,
    432244                                 unsigned int* vobj_vaddr);
    433245
    434 //////////////////////////////////////////////////////////////////////////
    435 // This function returns in the "buffer" argument the number of processors
    436 // in the cluster specified by the "cluster_xy" argument.
    437 // In case or error returned by syscall, it makes a giet_exit().
    438 //////////////////////////////////////////////////////////////////////////
    439 extern void giet_procnumber( unsigned int cluster_xy,
    440                              unsigned int buffer );
    441 
    442 //////////////////////////////////////////////////////////////////////////
    443 // This function supports access to the task's heap or to a remote heap:
    444 // - If (x < X_SIZE) and (y < Y_SIZE), this function returns the base
    445 //   address and length of the heap associated to any task running
    446 //   on cluster(x,y) => remote heap
    447 // - Else, this function returns the base address and length of the
    448 //   heap associated to the calling task => local heap
    449 //////////////////////////////////////////////////////////////////////////
     246extern void giet_vobj_get_length( char*         vspace_name,
     247                                  char*         vobj_name,
     248                                  unsigned int* vobj_vaddr);
     249
    450250extern void giet_heap_info( unsigned int* vaddr,
    451251                            unsigned int* length,
    … …  
    453253                            unsigned int  y );
    454254
    455 //////////////////////////////////////////////////////////////////////////
    456 // This function takes as input a virtual address (ptr argument),
    457 // and returns through the (px,py) arguments the coordinates of
    458 // the cluster containing the physical address associated to ptr.
    459 // In case of error (unmapped virtual address), it makes a giet_exit().
    460 //////////////////////////////////////////////////////////////////////////
    461255extern void giet_get_xy( void*          ptr,
    462256                         unsigned int*  px,
Note: See TracChangeset for help on using the changeset viewer.