Changeset 295 for soft/giet_vm/giet_libs


Ignore:
Timestamp:
Mar 26, 2014, 6:44:44 PM (11 years ago)
Author:
alain
Message:

Introducing a major release, to suppoort the tsar_generic_leti platform
and the various (external or internal) peripherals configurations.
The map.xml format has been modified, in order to support the new
vci_iopic componentand a new policy for peripherals initialisation.
The IRQs are nom described in the XICU and IOPIC components
(and not anymore in the processors).
To enforce this major change, the map.xml file signature changed:
The signature value must be: 0xDACE2014

This new release has been tested on the tsar_generic_leti platform
for the following mappings:

  • 4c_4p_sort_leti
  • 4c_4p_sort_leti_ext
  • 4c_4p_transpose_leti
  • 4c_4p_transpose_leti_ext
  • 4c_1p_four_leti_ext
Location:
soft/giet_vm/giet_libs
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_libs/barrier.c

    r258 r295  
    1515
    1616///////////////////////////////////////////////////////////////////////////////////
    17 //     barrier_init()
    18 // This function makes a cooperative initialisation of the barrier:
    19 // several tasks try to initialize the barrier, but the initialisation
    20 // is done by only one task, using LL/SC instructions.
     17// This function initializes the barrier: this should be done by a single task.
    2118///////////////////////////////////////////////////////////////////////////////////
    22 void barrier_init( giet_barrier_t * barrier, unsigned int value) {
    23     unsigned int * pinit  = (unsigned int *) &barrier->init;
    24     unsigned int * pcount = (unsigned int *) &barrier->count;
    25 
    26     // parallel initialisation using atomic instructions LL/SC
    27     // inputs : pinit, pcount, value
    28     // no output
    29     asm volatile ("_barrier_init_test:                  \n"
    30             "ll   $2,     0(%0)                   \n" /* read initial value */
    31             "bnez $2,     _barrier_init_done      \n"
    32             "move $3,     %2                      \n"
    33             "sc   $3,     0(%0)                   \n" /* write initial value */
    34             "beqz $3,     _barrier_init_test      \n"
    35             "move $3,     %2                      \n"
    36             "sw   $3,     0(%1)                   \n" /* write count */
    37             "_barrier_init_done:                  \n"
    38             :
    39             : "r"(pinit), "r"(pcount), "r"(value)
    40             : "$2", "$3");
     19void barrier_init( giet_barrier_t* barrier,
     20                   unsigned int    value )
     21{
     22    barrier->init  = value;
     23    barrier->count = value;
    4124}
    4225
    4326
    4427///////////////////////////////////////////////////////////////////////////////////
    45 //    barrier_wait()
    4628// This blocking function uses LL/SC to decrement the barrier's counter.
    4729// Then, it uses a busy_waiting mechanism if it is not the last.
    48 // (because the GIET does not support dynamic task scheduling/descheduling)
    4930///////////////////////////////////////////////////////////////////////////////////
    50 void barrier_wait(giet_barrier_t * barrier) {
     31void barrier_wait( giet_barrier_t* barrier )
     32{
    5133    unsigned int * pcount  = (unsigned int *) &barrier->count;
    5234    unsigned int maxcount = barrier->init;
    … …  
    5638    // - input : pointer on the barrier counter
    5739    // - output : counter value
    58     asm volatile ("_barrier_decrement:          \n"
     40    asm volatile ("_barrier_decrement:    \n"
    5941            "ll   %0, 0(%1)               \n"
    6042            "addi $3, %0,     -1          \n"
    … …  
    6850    // waking up all other waiting tasks
    6951
    70     if (count == 1) {
     52    if (count == 1)
     53    {
    7154        // last task
    7255        *pcount = maxcount;

  • soft/giet_vm/giet_libs/barrier.h

    r258 r295  
    1313///////////////////////////////////////////////////////////////////////////////////
    1414
    15 typedef struct giet_barrier_s {
     15typedef struct giet_barrier_s
     16{
    1617    char name[32];      // barrier name
    1718    unsigned int init;  // total number of participants
    … …  
    2324//////////////////////////////////////////////////////////////////////////////
    2425
    25 void barrier_init(giet_barrier_t * barrier, unsigned int value);
    26 void barrier_wait(giet_barrier_t * barrier);
     26void barrier_init( giet_barrier_t* barrier,
     27                   unsigned int    value );  // number of tasks 
     28
     29void barrier_wait( giet_barrier_t* barrier );
    2730
    2831#endif

  • soft/giet_vm/giet_libs/malloc.h

    r258 r295  
    88#ifndef _MALLOC_H_
    99#define _MALLOC_H_
     10
    1011//#define DEBUG_MALLOC 1
    1112

  • soft/giet_vm/giet_libs/stdio.c

    r289 r295  
    1919
    2020////////////////////////////////////////////////////////////////////////////////////
    21 // giet_procid()
    22 ////////////////////////////////////////////////////////////////////////////////////
    23 // This function returns the processor identifier.
    24 ////////////////////////////////////////////////////////////////////////////////////
    25 int giet_procid()
    26 {
    27     return sys_call( SYSCALL_PROCID,
    28                      0, 0, 0, 0 );
    29 }
    30 ////////////////////////////////////////////////////////////////////////////////////
    31 // giet_proctime()
    32 ////////////////////////////////////////////////////////////////////////////////////
    33 // This function returns the local processor time (clock cycles since boot)
    34 ////////////////////////////////////////////////////////////////////////////////////
    35 int giet_proctime()
    36 {
    37     return sys_call( SYSCALL_PROCTIME,
    38                      0, 0, 0, 0 );
    39 }
    40 
    41 
    42 ////////////////////////////////////////////////////////////////////////////////////
    4321/////////////////////  TTY device related system calls /////////////////////////////
    4422////////////////////////////////////////////////////////////////////////////////////
    4523
    46 ////////////////////////////////////////////////////////////////////////////////////
    47 // giet_tty_putc()
    48 ////////////////////////////////////////////////////////////////////////////////////
    49 // This function displays a single ascii character on a terminal.
    50 // The terminal index must be defined in the task context in the boot phase.
    51 // It doesn't use the TTY_PUT_IRQ interrupt, and the associated kernel buffer.
    52 // - Returns 1 if the character has been written, 0 otherwise.
    53 ////////////////////////////////////////////////////////////////////////////////////
    54 int giet_tty_putc(char byte)
    55 {
    56     return sys_call(SYSCALL_TTY_WRITE,
    57                     (unsigned int)(&byte),
    58                     1,
    59                     0xFFFFFFFF, 
    60                     0);
    61 }
    62 ////////////////////////////////////////////////////////////////////////////////////
    63 // giet_tty_puts()
    64 ////////////////////////////////////////////////////////////////////////////////////
    65 // This function displays a string on a terminal.
    66 // The terminal index must be defined in the task context in the boot phase.
    67 // The string must be terminated by a NUL character.
    68 // It doesn't use the TTY_PUT_IRQ interrupt, and the associated kernel buffer.
    69 // - Returns the number of written characters.
    70 ////////////////////////////////////////////////////////////////////////////////////
    71 int giet_tty_puts(char * buf)
    72 {
    73     unsigned int length = 0;
    74     while (buf[length] != 0) { length++; }
    75     return sys_call(SYSCALL_TTY_WRITE,
    76                    (unsigned int)buf,
    77                    length,
    78                    0xFFFFFFFF,
    79                    0);
    80 }
    81 ////////////////////////////////////////////////////////////////////////////////////
    82 // giet_tty_putw()
    83 ////////////////////////////////////////////////////////////////////////////////////
    84 // This function displays the value of a 32-bit word with decimal characters.
    85 // The terminal index must be defined in the task context in the boot phase.
    86 // It doesn't use the TTY_PUT_IRQ interrupt, and the associated kernel buffer.
    87 // Returns the number of written characters (should be equal to ten).
    88 ////////////////////////////////////////////////////////////////////////////////////
    89 int giet_tty_putw(unsigned int val)
    90 {
    91     char buf[10];
    92     unsigned int i;
    93     for (i = 0; i < 10; i++)
    94     {
    95         buf[9 - i] = (val % 10) + 0x30;
    96         val = val / 10;
    97     }
    98     return sys_call(SYSCALL_TTY_WRITE,
    99                    (unsigned int)buf,
    100                    10,
    101                    0xFFFFFFFF,
    102                    0);
    103 }
    104 ////////////////////////////////////////////////////////////////////////////////////
    105 // giet_tty_getc()
    106 ////////////////////////////////////////////////////////////////////////////////////
    107 // This blocking function fetches a single ascii character from a terminal.
    108 // The terminal index must be defined in the task context in the boot phase.
    109 // It uses the IRQ_GET interrupt, and the associated kernel buffer.
    110 // - Returns 0 when completed.
    111 ////////////////////////////////////////////////////////////////////////////////////
    112 int giet_tty_getc(char * byte)
    113 {
    114     unsigned int ret = 0;
    115     while (ret == 0)
     24////////////////////////////////////////
     25void giet_tty_printf( char* format, ...)
     26{
     27    va_list args;
     28    va_start( args, format );
     29
     30    int          ret;     // return value from the syscalls
     31    unsigned int channel = 0xFFFFFFFF;
     32
     33printf_text:
     34
     35    while (*format)
     36    {
     37        unsigned int i;
     38        for (i = 0 ; format[i] && (format[i] != '%') ; i++);
     39        if (i)
     40        {
     41            ret = sys_call(SYSCALL_TTY_WRITE,
     42                           (unsigned int)format,
     43                           i,
     44                           channel,
     45                           0);
     46
     47            if (ret != i) goto return_error;
     48
     49            format += i;
     50        }
     51        if (*format == '%')
     52        {
     53            format++;
     54            goto printf_arguments;
     55        }
     56    }
     57
     58    va_end( args );
     59    return;
     60
     61printf_arguments:
     62
     63    {
     64        char buf[20];
     65        char * pbuf;
     66        unsigned int len = 0;
     67        static const char HexaTab[] = "0123456789ABCDEF";
     68        unsigned int i;
     69
     70        switch (*format++)
     71        {
     72            case ('c'):             /* char conversion */
     73            {
     74                int val = va_arg( args, int );
     75                len = 1;
     76                buf[0] = val;
     77                pbuf = &buf[0];
     78                break;
     79            }
     80            case ('d'):             /* 32 bits decimal signed integer */
     81            {
     82                int val = va_arg( args, int );
     83                if (val < 0)
     84                {
     85                    val = -val;
     86                    ret = sys_call(SYSCALL_TTY_WRITE,
     87                                   (unsigned int)"-",
     88                                   1,
     89                                   channel,
     90                                   0);
     91                    if (ret != 1) goto return_error;
     92                }
     93                for(i = 0; i < 10; i++)
     94                {
     95                    buf[9 - i] = HexaTab[val % 10];
     96                    if (!(val /= 10)) break;
     97                }
     98                len =  i + 1;
     99                pbuf = &buf[9 - i];
     100                break;
     101            }
     102            case ('u'):             /* 32 bits decimal unsigned integer */
     103            {
     104                unsigned int val = va_arg( args, unsigned int );
     105                for(i = 0; i < 10; i++)
     106                {
     107                    buf[9 - i] = HexaTab[val % 10];
     108                    if (!(val /= 10)) break;
     109                }
     110                len =  i + 1;
     111                pbuf = &buf[9 - i];
     112                break;
     113            }
     114            case ('x'):             /* 32 bits hexadecimal integer */
     115            {
     116                unsigned int val = va_arg( args, unsigned int );
     117                ret = sys_call(SYSCALL_TTY_WRITE,
     118                               (unsigned int)"0x",
     119                               2,
     120                               channel,
     121                               0);
     122                if (ret != 2) goto return_error;       
     123                for(i = 0; i < 8; i++)
     124                {
     125                    buf[7 - i] = HexaTab[val % 16];
     126                    if (!(val /= 16))  break;
     127                }
     128                len =  i + 1;
     129                pbuf = &buf[7 - i];
     130                break;
     131            }
     132            case ('l'):            /* 64 bits hexadecimal unsigned */
     133            {
     134                unsigned long long val = va_arg( args, unsigned long long );
     135                ret = sys_call(SYSCALL_TTY_WRITE,
     136                               (unsigned int)"0x",
     137                               2,
     138                               channel,
     139                               0);
     140                if (ret != 2) goto return_error;
     141                for(i = 0; i < 16; i++)
     142                {
     143                    buf[15 - i] = HexaTab[val % 16];
     144                    if (!(val /= 16))  break;
     145                }
     146                len =  i + 1;
     147                pbuf = &buf[15 - i];
     148                break;
     149            }
     150            case ('s'):             /* string */
     151            {
     152                char* str = va_arg( args, char* );
     153                while (str[len])
     154                {
     155                    len++;
     156                }
     157                pbuf = str;
     158                break;
     159            }
     160            default:
     161                goto return_error;
     162        }
     163
     164        ret = sys_call(SYSCALL_TTY_WRITE,
     165                       (unsigned int)pbuf,
     166                       len,
     167                       channel,
     168                       0);
     169        if (ret != len)  goto return_error;
     170       
     171        goto printf_text;
     172    }
     173
     174return_error:
     175
     176    va_end( args );
     177    giet_exit("error in giet_tty_printf()");
     178} // end giet_tty_printf()
     179
     180////////////////////////////////////////
     181void giet_shr_printf( char* format, ...)
     182{
     183    va_list args;
     184    va_start( args, format );
     185
     186    int          ret;     // return value from the syscalls
     187    unsigned int channel = 0;
     188    unsigned int sr_save;
     189
     190    sys_call( SYSCALL_TTY_GET_LOCK,
     191              channel,
     192              (unsigned int)&sr_save,
     193              0, 0 );
     194
     195printf_text:
     196
     197    while (*format)
     198    {
     199        unsigned int i;
     200        for (i = 0 ; format[i] && (format[i] != '%') ; i++);
     201        if (i)
     202        {
     203            ret = sys_call(SYSCALL_TTY_WRITE,
     204                           (unsigned int)format,
     205                           i,
     206                           channel,
     207                           0);
     208
     209            if (ret != i) goto return_error;
     210
     211            format += i;
     212        }
     213        if (*format == '%')
     214        {
     215            format++;
     216            goto printf_arguments;
     217        }
     218    }
     219
     220    sys_call( SYSCALL_TTY_RELEASE_LOCK,
     221              channel,
     222              (unsigned int)&sr_save,
     223              0, 0 );
     224 
     225    va_end( args );
     226    return;
     227
     228printf_arguments:
     229
     230    {
     231        char buf[20];
     232        char * pbuf;
     233        unsigned int len = 0;
     234        static const char HexaTab[] = "0123456789ABCDEF";
     235        unsigned int i;
     236
     237        switch (*format++)
     238        {
     239            case ('c'):             /* char conversion */
     240            {
     241                int val = va_arg( args, int );
     242                len = 1;
     243                buf[0] = val;
     244                pbuf = &buf[0];
     245                break;
     246            }
     247            case ('d'):             /* 32 bits decimal signed integer */
     248            {
     249                int val = va_arg( args, int );
     250                if (val < 0)
     251                {
     252                    val = -val;
     253                    ret = sys_call(SYSCALL_TTY_WRITE,
     254                                   (unsigned int)"-",
     255                                   1,
     256                                   channel,
     257                                   0);
     258                    if (ret != 1) goto return_error;
     259                }
     260                for(i = 0; i < 10; i++)
     261                {
     262                    buf[9 - i] = HexaTab[val % 10];
     263                    if (!(val /= 10)) break;
     264                }
     265                len =  i + 1;
     266                pbuf = &buf[9 - i];
     267                break;
     268            }
     269            case ('u'):             /* 32 bits decimal unsigned integer */
     270            {
     271                unsigned int val = va_arg( args, unsigned int );
     272                for(i = 0; i < 10; i++)
     273                {
     274                    buf[9 - i] = HexaTab[val % 10];
     275                    if (!(val /= 10)) break;
     276                }
     277                len =  i + 1;
     278                pbuf = &buf[9 - i];
     279                break;
     280            }
     281            case ('x'):             /* 32 bits hexadecimal integer */
     282            {
     283                unsigned int val = va_arg( args, unsigned int );
     284                ret = sys_call(SYSCALL_TTY_WRITE,
     285                               (unsigned int)"0x",
     286                               2,
     287                               channel,
     288                               0);
     289                if (ret != 2) goto return_error;       
     290                for(i = 0; i < 8; i++)
     291                {
     292                    buf[7 - i] = HexaTab[val % 16];
     293                    if (!(val /= 16))  break;
     294                }
     295                len =  i + 1;
     296                pbuf = &buf[7 - i];
     297                break;
     298            }
     299            case ('l'):            /* 64 bits hexadecimal unsigned */
     300            {
     301                unsigned long long val = va_arg( args, unsigned long long );
     302                ret = sys_call(SYSCALL_TTY_WRITE,
     303                               (unsigned int)"0x",
     304                               2,
     305                               channel,
     306                               0);
     307                if (ret != 2) goto return_error;
     308                for(i = 0; i < 16; i++)
     309                {
     310                    buf[15 - i] = HexaTab[val % 16];
     311                    if (!(val /= 16))  break;
     312                }
     313                len =  i + 1;
     314                pbuf = &buf[15 - i];
     315                break;
     316            }
     317            case ('s'):             /* string */
     318            {
     319                char* str = va_arg( args, char* );
     320                while (str[len])
     321                {
     322                    len++;
     323                }
     324                pbuf = str;
     325                break;
     326            }
     327            default:
     328                goto return_error;
     329        }
     330
     331        ret = sys_call(SYSCALL_TTY_WRITE,
     332                       (unsigned int)pbuf,
     333                       len,
     334                       channel,
     335                       0);
     336        if (ret != len)  goto return_error;
     337       
     338        goto printf_text;
     339    }
     340
     341return_error:
     342
     343    sys_call( SYSCALL_TTY_RELEASE_LOCK,
     344              channel,
     345              (unsigned int)&sr_save,
     346              0, 0 );
     347
     348    va_end( args );
     349    giet_exit("error in giet_shr_printf()");
     350}  // end giet_shr_printf()
     351
     352
     353/////////////////////////////////
     354void giet_tty_getc( char * byte )
     355{
     356    int ret;
     357
     358    do
    116359    {
    117360        ret = sys_call(SYSCALL_TTY_READ,
    … …  
    120363                      0xFFFFFFFF,          // channel index from task context
    121364                      0);
    122     }
    123     return 0;
    124 }
    125 ////////////////////////////////////////////////////////////////////////////////////
    126 // giet_tty_gets()
    127 ////////////////////////////////////////////////////////////////////////////////////
    128 // This blocking function fetches a string from a terminal to a fixed length buffer.
    129 // The terminal index must be defined in the task context in the boot phase.
    130 // It uses the TTY_GET_IRQ interrupt, anf the associated kernel buffer.
    131 // - Returns 0 when completed.
    132 // - Up to (bufsize - 1) characters (including the non printable characters)
    133 //   will be copied into buffer, and the string is always completed by a NUL
    134 //   character.
    135 // - The <LF> character is interpreted, and the function close the string with a
    136 //   NUL character if <LF> is read.
    137 // - The <DEL> character is interpreted, and the corresponding character(s) are
    138 //   removed from the target buffer.
    139 ////////////////////////////////////////////////////////////////////////////////////
    140 int giet_tty_gets( char*        buf,
    141                    unsigned int bufsize)
    142 {
    143     unsigned int ret;
     365        if ( ret < 0 ) giet_exit("error in giet_tty_getc()");
     366    }
     367    while (ret != 1);
     368}
     369
     370/////////////////////////////////////
     371void giet_tty_gets( char*        buf,
     372                    unsigned int bufsize )
     373{
     374    int           ret;
    144375    unsigned char byte;
    145     unsigned int index = 0;
    146 
     376    unsigned int  index = 0;
     377 
    147378    while (index < (bufsize - 1))
    148379    {
    … …  
    154385                           0xFFFFFFFF,
    155386                           0);
     387            if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
    156388        }
    157389        while (ret != 1);
    … …  
    172404    }
    173405    buf[index] = 0;
    174     return 0;
    175 }
    176 ////////////////////////////////////////////////////////////////////////////////////
    177 // giet_tty_getw()
    178 ////////////////////////////////////////////////////////////////////////////////////
    179 // This blocking function fetches a string of decimal characters (most
    180 // significant digit first) to build a 32-bit unsigned integer.
    181 // The terminal index must be defined in the task context in the boot phase.
    182 // It uses the TTY_GET_IRQ interrupt, anf the associated kernel buffer.
    183 // - Returns necessarily 0 when completed.
    184 //
    185 // - The non-blocking system function _tty_read_irq is called several times,
    186 //   and the decimal characters are written in a 32 characters buffer until a
    187 //   <LF> character is read.
    188 // - The <DEL> character is interpreted, and previous characters can be
    189 //   cancelled. All others characters are ignored.
    190 // - When the <LF> character is received, the string is converted to an
    191 //   unsigned int value. If the number of decimal digit is too large for the 32
    192 //   bits range, the zero value is returned.
    193 ////////////////////////////////////////////////////////////////////////////////////
    194 int giet_tty_getw(unsigned int * val)
     406}
     407
     408///////////////////////////////////////
     409void giet_tty_getw( unsigned int* val )
    195410{
    196411    unsigned char buf[32];
    197     unsigned char byte;
    198     unsigned int save = 0;
    199     unsigned int dec = 0;
    200     unsigned int done = 0;
    201     unsigned int overflow = 0;
    202     unsigned int max = 0;
    203     unsigned int i;
    204     unsigned int ret;
    205 
     412    unsigned int  string_byte   = 0x00000000;    // string containing one single byte
     413    unsigned int  string_cancel = 0x00082008;    // string containing BS/SPACE/BS
     414    unsigned int  save = 0;
     415    unsigned int  dec = 0;
     416    unsigned int  done = 0;
     417    unsigned int  overflow = 0;
     418    unsigned int  length = 0;
     419    unsigned int  i;
     420    unsigned int  channel = 0xFFFFFFFF;
     421    int           ret;      // return value from syscalls
     422 
     423    // get characters
    206424    while (done == 0)
    207425    {
     426        // read one character
    208427        do
    209428        {
    210             ret = sys_call(SYSCALL_TTY_READ,
    211                            (unsigned int)(&byte),
    212                            1,
    213                            0xFFFFFFFF,
    214                            0);
     429            ret = sys_call( SYSCALL_TTY_READ,
     430                            (unsigned int)(&string_byte),
     431                            1,
     432                            channel,
     433                            0);
     434            if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
    215435        }
    216436        while (ret != 1);
    217437
    218         if ((byte > 0x2F) && (byte < 0x3A))  /* decimal character */
    219         {
    220             buf[max] = byte;
    221             max++;
    222             giet_tty_putc(byte);
    223         }
    224         else if ((byte == 0x0A))   /* LF */
     438        // analyse character
     439        if ((string_byte > 0x2F) && (string_byte < 0x3A))  /* decimal character */
     440        {
     441            buf[length] = (unsigned char)string_byte;
     442            length++;
     443
     444            // echo
     445            ret = sys_call( SYSCALL_TTY_WRITE,
     446                            (unsigned int)(&string_byte),
     447                            1,
     448                            channel,
     449                            0 );
     450            if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
     451        }
     452        else if (string_byte == 0x0A)                     /* LF character */
    225453        {
    226454            done = 1;
    227455        }
    228         else if (byte == 0x7F)   /* DEL */
    229         {
    230             if (max > 0)
    231             {
    232                 max--;      /* cancel the character */
    233                 giet_tty_putc(0x08);
    234                 giet_tty_putc(0x20);
    235                 giet_tty_putc(0x08);
    236             }
    237         }
    238         if (max == 32)  /* decimal string overflow */
    239         {
    240             for (i = 0; i < max; i++)
    241             {
    242                 /* cancel the string */
    243                 giet_tty_putc(0x08);
    244                 giet_tty_putc(0x20);
    245                 giet_tty_putc(0x08);
    246             }
    247             giet_tty_putc(0x30);
    248             *val = 0;      /* return 0 value */
    249             return 0;
    250         }
    251     }
    252 
    253     /* string conversion */
    254     for (i = 0; i < max; i++)
    255     {
    256         dec = dec * 10 + (buf[i] - 0x30);
    257         if (dec < save)  overflow = 1;
    258         save = dec;
    259     }
    260 
    261     /* check overflow */
    262     if (overflow == 0)
    263     {
    264         *val = dec; /* return decimal value */
    265     }
    266     else
    267     {
    268         for (i = 0; i < max; i++)
    269         {
    270             /* cancel the string */
    271             giet_tty_putc(0x08);
    272             giet_tty_putc(0x20);
    273             giet_tty_putc(0x08);
    274         }
    275         giet_tty_putc(0x30);
    276         *val = 0;         /* return 0 value */
    277     }
    278     return 0;
    279 }
    280 ////////////////////////////////////////////////////////////////////////////////////
    281 // giet_tty_printf()
    282 ////////////////////////////////////////////////////////////////////////////////////
    283 // This function is a simplified version of the mutek_printf() function.
    284 // The terminal index must be defined in the calling task context.
    285 // It doesn't use the IRQ_PUT interrupt, and the associated kernel buffer.
    286 // Only a limited number of formats are supported:
    287 //   - %d : signed decimal
    288 //   - %u : unsigned decimal
    289 //   - %x : hexadecimal
    290 //   - %c : char
    291 //   - %s : string
    292 // - Returns 0 if success, > 0 if error.
    293 ////////////////////////////////////////////////////////////////////////////////////
    294 int giet_tty_printf(char * format, ...)
    295 {
    296     va_list ap;
    297     va_start(ap, format);
    298     unsigned int ret;
    299 
    300     if (NB_TTY_CHANNELS == 1)
    301     {
    302         ret = sys_call(SYSCALL_TTY_LOCK, 0, 0, 0, 0); // Get TTY lock
    303     }
    304 
    305 printf_text:
    306 
    307     while (*format)
    308     {
    309         unsigned int i;
    310         for (i = 0 ; format[i] && (format[i] != '%') ; i++);
    311         if (i)
    312         {
    313             ret = sys_call(SYSCALL_TTY_WRITE,
    314                            (unsigned int)format,
    315                            i,
    316                            0xFFFFFFFF,
    317                            0);
    318 
    319             if (ret != i) goto return_error;
    320 
    321             format += i;
    322         }
    323         if (*format == '%')
    324         {
    325             format++;
    326             goto printf_arguments;
    327         }
    328     }
    329 
    330     if (NB_TTY_CHANNELS == 1)
    331     {
    332         ret = sys_call(SYSCALL_TTY_LOCK, 1, 0, 0, 0); // Release TTY lock
    333     }
    334 
    335     va_end(ap);
    336     return 0;
    337 
    338 printf_arguments:
    339 
    340     {
    341         int val = va_arg(ap, long);
    342         char buf[20];
    343         char * pbuf;
    344         unsigned int len = 0;
    345         static const char HexaTab[] = "0123456789ABCDEF";
    346         unsigned int i;
    347 
    348         switch (*format++) {
    349             case ('c'):             /* char conversion */
    350                 len = 1;
    351                 buf[0] = val;
    352                 pbuf = buf;
    353                 break;
    354             case ('d'):             /* decimal signed integer */
    355                 if (val < 0)
    356                 {
    357                     val = -val;
    358                     ret = sys_call(SYSCALL_TTY_WRITE,
    359                                    (unsigned int)"-",
    360                                    1,
    361                                    0xFFFFFFFF,
    362                                    0);
    363                     if (ret != 1) goto return_error;
    364                 }
    365             case ('u'):             /* decimal unsigned integer */
    366                 for(i = 0; i < 10; i++)
    367                 {
    368                     buf[9 - i] = HexaTab[val % 10];
    369                     if (!(val /= 10)) break;
    370                 }
    371                 len =  i + 1;
    372                 pbuf = &buf[9 - i];
    373                 break;
    374             case ('x'):             /* hexadecimal integer */
    375                 ret = sys_call(SYSCALL_TTY_WRITE,
    376                                (unsigned int)"0x",
    377                                2,
    378                                0xFFFFFFFF,
    379                                0);
    380                 if (ret != 2) goto return_error;       /* return error */
    381                 for(i = 0; i < 8; i++)
    382                 {
    383                     buf[7 - i] = HexaTab[val % 16U];
    384                     if (!(val /= 16U))  break;
    385                 }
    386                 len =  i + 1;
    387                 pbuf = &buf[7 - i];
    388                 break;
    389             case ('s'):             /* string */
    390                 {
    391                     char * str = (char *) val;
    392                     while (str[len])
    393                     {
    394                         len++;
    395                     }
    396                     pbuf = (char *) val;
    397                 }
    398                 break;
    399             default:
    400                 goto printf_text;
    401         }
    402 
    403         ret = sys_call(SYSCALL_TTY_WRITE,
    404                        (unsigned int)pbuf,
    405                        len,
    406                        0xFFFFFFFF,
    407                        0);
    408         if (ret != len)  goto return_error;
    409        
    410         goto printf_text;
    411     }
    412 
    413 return_error:
    414     if (NB_TTY_CHANNELS == 1)
    415     {
    416         ret = sys_call(SYSCALL_TTY_LOCK, 1, 0, 0, 0); // Release TTY lock
    417     }
    418 
    419     return 1;
    420 }
    421 
     456        else if ( (string_byte == 0x7F) ||                /* DEL character */
     457                  (string_byte == 0x08) )                 /* BS  character */
     458        {
     459            if ( length > 0 )
     460            {
     461                length--;    // cancel the character
     462
     463                ret = sys_call( SYSCALL_TTY_WRITE,
     464                                (unsigned int)(&string_cancel),
     465                                3,
     466                                channel,
     467                                0 );
     468                if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
     469            }
     470        }
     471
     472        // test buffer overflow
     473        if ( length >= 32 ) 
     474        {
     475            overflow = 1;
     476            done     = 1;
     477        }
     478    }  // end while characters
     479
     480    // string to int conversion with overflow detection
     481    if ( overflow == 0 )
     482    {
     483        for (i = 0; (i < length) && (overflow == 0) ; i++)
     484        {
     485            dec = dec * 10 + (buf[i] - 0x30);
     486            if (dec < save)  overflow = 1;
     487            save = dec;
     488        }
     489    }
     490
     491    // final evaluation
     492    if ( overflow == 0 )
     493    {
     494        // return value
     495        *val = dec;
     496    }
     497    else
     498    {
     499        // cancel all echo characters
     500        for (i = 0; i < length ; i++)
     501        {
     502            ret = sys_call( SYSCALL_TTY_WRITE,
     503                            (unsigned int)(&string_cancel),
     504                            3,
     505                            channel,
     506                            0 );
     507            if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
     508        }
     509        // echo character '0'
     510        string_byte = 0x30;
     511        ret = sys_call( SYSCALL_TTY_WRITE,
     512                        (unsigned int)(&string_byte),
     513                        1,
     514                        channel,
     515                        0 );
     516        if ( ret < 0 ) giet_exit();
     517
     518        // return 0 value
     519        *val = 0;
     520    }
     521}
    422522
    423523
    … …  
    426526//////////////////////////////////////////////////////////////////////////////////
    427527
    428 //////////////////////////////////////////////////////////////////////////////////
    429 // giet_timer_start()
    430 //////////////////////////////////////////////////////////////////////////////////
    431 // This function activates the private user timer allocated to the calling task
    432 // in the boot phase.
    433 // - Returns 0 if success, > 0 if error.
    434 //////////////////////////////////////////////////////////////////////////////////
    435 int giet_timer_start()
    436 {
    437     return sys_call( SYSCALL_TIMER_START,
    438                      0, 0, 0, 0 );
    439 }
    440 //////////////////////////////////////////////////////////////////////////////////
    441 // giet_timer_stop()
    442 //////////////////////////////////////////////////////////////////////////////////
    443 // This function activates the user timer allocated to the calling task.
    444 // - Returns 0 if success, > 0 if error.
    445 //////////////////////////////////////////////////////////////////////////////////
    446 int giet_timer_stop()
    447 {
    448     return sys_call( SYSCALL_TIMER_STOP,
    449                      0, 0, 0, 0 );
     528///////////////////////
     529void giet_timer_start()
     530{
     531    if ( sys_call( SYSCALL_TIMER_START, 0, 0, 0, 0 ) )
     532       giet_exit("error in giet_timer_start()");
     533}
     534
     535//////////////////////
     536void giet_timer_stop()
     537{
     538    if ( sys_call( SYSCALL_TIMER_STOP, 0, 0, 0, 0 ) )
     539        giet_exit("error in giet_timer_stop()");
    450540}
    451541
    … …  
    455545//////////////////////////////////////////////////////////////////////////////////
    456546
    457 //////////////////////////////////////////////////////////////////////////////////
    458 // giet_fb_sync_write()
    459 //////////////////////////////////////////////////////////////////////////////////
    460 // This blocking function use a memory copy strategy to transfer data from a
    461 // user buffer to the frame buffer device in kernel space.
    462 //     offset : offset (in bytes) in the frame buffer
    463 //     buffer : base address of the memory buffer
    464 //     length : number of bytes to be transfered
    465 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
    466 //////////////////////////////////////////////////////////////////////////////////
    467 int giet_fb_sync_write( unsigned int offset,
     547////////////////////////////////////////////
     548void giet_fb_sync_write( unsigned int offset,
    468549                        void *       buffer,
    469550                        unsigned int length )
    470551{
    471     return sys_call( SYSCALL_FB_SYNC_WRITE,
    472                      offset,
    473                      (unsigned int)buffer,
    474                      length,
    475                      0 );
    476 }
    477 //////////////////////////////////////////////////////////////////////////////////
    478 // giet_fb_sync_read()
    479 //////////////////////////////////////////////////////////////////////////////////
    480 // This blocking function use a memory copy strategy to transfer data from the
    481 // frame buffer device in kernel space to an user buffer.
    482 //     offset : offset (in bytes) in the frame buffer
    483 //     buffer : base address of the user buffer
    484 //     length : number of bytes to be transfered
    485 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
    486 //////////////////////////////////////////////////////////////////////////////////
    487 int giet_fb_sync_read( unsigned int offset,
    488                        void *       buffer,
    489                        unsigned int length )
    490 {
    491     return sys_call( SYSCALL_FB_SYNC_READ,
    492                      offset,
    493                      (unsigned int)buffer,
    494                      length,
    495                      0 );
    496 }
    497 //////////////////////////////////////////////////////////////////////////////////
    498 // giet_fb_cma_init()
    499 //////////////////////////////////////////////////////////////////////////////////
    500 // This function initializes the two chbuf SRC an DST used by the CMA controller
    501 // and activates the CMA channel allocated to the calling task.
    502 // - buf0   : first user buffer virtual address
    503 // - buf0   : second user buffer virtual address
    504 // - length : buffer size (bytes)
    505 // - Returns 0 if success, > 0 if error.
    506 //////////////////////////////////////////////////////////////////////////////////
    507 int giet_fb_cma_init( void *       buf0,
    508                       void *       buf1,
    509                       unsigned int length )
    510 {
    511     return sys_call( SYSCALL_FB_CMA_INIT,
    512                      (unsigned int)buf0,
    513                      (unsigned int)buf1,
    514                      length,
    515                      0 );
    516 }
    517 //////////////////////////////////////////////////////////////////////////////////
    518 // giet_fb_cma_write()
    519 //////////////////////////////////////////////////////////////////////////////////
    520 // This function set the valid status for one of the SRC user buffer.
    521 // and reset the valid status for the DST frame buffer.
    522 // - bufffer_id : 0 => buf0 valid is set / not 0  => buf1 valid is set
    523 // - Returns 0 if success, > 0 if error.
    524 //////////////////////////////////////////////////////////////////////////////////
    525 int giet_fb_cma_write( unsigned int buffer_id )
    526 {
    527     return sys_call( SYSCALL_FB_CMA_WRITE,
    528                      buffer_id,
    529                      0, 0, 0 );
    530 }
    531 //////////////////////////////////////////////////////////////////////////////////
    532 // giet_fb_cma_stop()
    533 //////////////////////////////////////////////////////////////////////////////////
    534 // This function desactivates the CMA channel allocated to the calling task.
    535 // - Returns 0 if success, > 0 if error.
    536 //////////////////////////////////////////////////////////////////////////////////
    537 int giet_fb_cma_stop( )
    538 {
    539     return sys_call( SYSCALL_FB_CMA_STOP,
    540                      0, 0, 0, 0 );
     552    if ( sys_call( SYSCALL_FB_SYNC_WRITE,
     553                   offset,
     554                   (unsigned int)buffer,
     555                   length,
     556                   0 ) )  giet_exit("error in giet_fb_sync_write()");
     557}
     558
     559///////////////////////////////////////////
     560void giet_fb_sync_read( unsigned int offset,
     561                        void *       buffer,
     562                        unsigned int length )
     563{
     564    if ( sys_call( SYSCALL_FB_SYNC_READ,
     565                   offset,
     566                   (unsigned int)buffer,
     567                   length,
     568                   0 ) )   giet_exit("error in giet_fb_sync_read()");
     569}
     570
     571/////////////////////////////////////////
     572void giet_fb_cma_init( void *       buf0,
     573                       void *       buf1,
     574                       unsigned int length )
     575{
     576    if ( sys_call( SYSCALL_FB_CMA_INIT,
     577                   (unsigned int)buf0,
     578                   (unsigned int)buf1,
     579                   length,
     580                   0 ) )   giet_exit("error in giet_fb_cma_init()");
     581}
     582
     583///////////////////////////////////////////////
     584void giet_fb_cma_write( unsigned int buffer_id )
     585{
     586    if ( sys_call( SYSCALL_FB_CMA_WRITE,
     587                   buffer_id,
     588                   0, 0, 0 ) )   giet_exit("error in giet_fb_cma_write()");
     589}
     590
     591////////////////////////
     592void giet_fb_cma_stop()
     593{
     594    if ( sys_call( SYSCALL_FB_CMA_STOP,
     595                   0, 0, 0, 0 ) )    giet_exit("error in giet_fb_cma_stop()");
    541596}
    542597
    … …  
    546601//////////////////////////////////////////////////////////////////////////////////
    547602
    548 //////////////////////////////////////////////////////////////////////////////////
    549 // giet_nic_cma_init()
    550 //////////////////////////////////////////////////////////////////////////////////
    551 // This function initializes the memory chbuf used by the CMA controller,
    552 // activates the NIC channel allocated to the calling task, and the CMA channel.
    553 // - tx     : RX channel if 0 / TX channel if non 0
    554 // - buf0   : first user buffer virtual address
    555 // - buf1   : second user buffer virtual address
    556 // - length : buffer size (bytes)
    557 // - Returns 0 if success, > 0 if error
    558 //////////////////////////////////////////////////////////////////////////////////
    559 int giet_nic_cma_start()
    560 {
    561     return sys_call( SYSCALL_NIC_CMA_START,
    562                      0, 0, 0, 0 );
    563 }
    564 //////////////////////////////////////////////////////////////////////////////////
    565 // giet_nic_cma_stop()
    566 //////////////////////////////////////////////////////////////////////////////////
    567 // This function desactivates the NIC channel and the two CMA channels
    568 // allocated to the calling task.
    569 // - Returns 0 if success, > 0 if error.
    570 //////////////////////////////////////////////////////////////////////////////////
    571 int giet_nic_cma_stop( )
    572 {
    573     return sys_call( SYSCALL_NIC_CMA_STOP,
    574                      0, 0, 0, 0 );
    575 }
    576 
    577 
    578 //////////////////////////////////////////////////////////////////////////////////
    579 ///////////////////// Miscellaneous system calls /////////////////////////////////
    580 //////////////////////////////////////////////////////////////////////////////////
    581 
    582 ///////////////////////////////////////////////////////////////////////////////////
    583 // giet_assert()
    584 ///////////////////////////////////////////////////////////////////////////////////
    585 // This function uses the giet_tty_puts() and giet_exit() system calls.
    586 ///////////////////////////////////////////////////////////////////////////////////
    587 void giet_assert( unsigned int condition,
    588                   char*        string )
    589 {
    590     if ( condition == 0 )
    591     {
    592         giet_tty_puts( string );
    593         giet_exit();
    594     }
    595 }
    596 //////////////////////////////////////////////////////////////////////////////////
    597 // giet_vobj_get_vbase()
    598 //////////////////////////////////////////////////////////////////////////////////
    599 // This function writes in argument (vobj_vaddr) the virtual base address
    600 // of a vobj (defined in the mapping_info data structure), identified by
    601 // the two arguments (vspace_name and vobj_name).
    602 // The (vobj_type) argument is redundant, and used for coherence checking.
    603 // - Returns the address if success,  0 if error ( not defined or wrong type )
    604 //////////////////////////////////////////////////////////////////////////////////
    605 int giet_vobj_get_vbase( char*         vspace_name,
    606                          char*         vobj_name,
    607                          unsigned int  vobj_type,
    608                          unsigned int* vobj_vaddr )
    609 {
    610     return sys_call( SYSCALL_VOBJ_GET_VBASE,
    611                      (unsigned int) vspace_name,
    612                      (unsigned int) vobj_name,
    613                      (unsigned int) vobj_type,
    614                      (unsigned int) vobj_vaddr );
    615 }
    616 ////////////////////////////////////////////////////////////////////////////////////
    617 // giet_proc_number()
    618 ////////////////////////////////////////////////////////////////////////////////////
    619 // This function returns in the buffer argument the number of processors
    620 // in the cluster specified by the cluster_id argument.
    621 // - Returns 0 if success, > 0 if error ( cluster index too large )
    622 ////////////////////////////////////////////////////////////////////////////////////
    623 int giet_proc_number( unsigned int  cluster_id,
    624                       unsigned int* buffer )
    625 {
    626     return sys_call(SYSCALL_PROC_NUMBER, cluster_id, (unsigned int) buffer, 0, 0);
    627 }
    628 //////////////////////////////////////////////////////////////////////////////////
    629 // giet_exit()
    630 //////////////////////////////////////////////////////////////////////////////////
    631 // This function stops execution of the calling task with a TTY message,
    632 // the user task is descheduled and becomes not runable.
    633 // It does not consume processor cycles anymore.
    634 //////////////////////////////////////////////////////////////////////////////////
    635 void giet_exit()
    636 {
    637     sys_call( SYSCALL_EXIT,
    638               0, 0, 0, 0 );
    639 }
    640 //////////////////////////////////////////////////////////////////////////////////
    641 // giet_context_switch()
    642 //////////////////////////////////////////////////////////////////////////////////
    643 // The user task calling this function is descheduled and
    644 // the processor is allocated to another task.
    645 //////////////////////////////////////////////////////////////////////////////////
    646 int giet_context_switch()
    647 {
    648     return sys_call( SYSCALL_CTX_SWITCH,
    649                      0, 0, 0, 0 );
    650 }
    651 //////////////////////////////////////////////////////////////////////////////////
    652 // giet_proc_task_id()
    653 //////////////////////////////////////////////////////////////////////////////////
    654 // This functions returns the local task id.
    655 // If processor has n tasks the local task index is ranging from 0 to n-1
    656 //////////////////////////////////////////////////////////////////////////////////
    657 int giet_proc_task_id()
    658 {
    659     return sys_call( SYSCALL_LOCAL_TASK_ID,
    660                      0, 0, 0, 0 );
    661 }
    662 //////////////////////////////////////////////////////////////////////////////////
    663 // giet_heap_info()
    664 //////////////////////////////////////////////////////////////////////////////////
    665 // This function returns the base address and size of the current task's heap
    666 //////////////////////////////////////////////////////////////////////////////////
    667 int giet_heap_info( unsigned int* vaddr,
    668                              unsigned int* length )
    669 {
    670     return sys_call( SYSCALL_HEAP_INFO,
    671                      (unsigned int)vaddr,
    672                      (unsigned int)length,
    673                      0, 0 );
    674 }
    675 //////////////////////////////////////////////////////////////////////////////////
    676 // giet_global_task_id()
    677 //////////////////////////////////////////////////////////////////////////////////
    678 // This functions returns the global task id, which is unique in all the giet.
    679 //////////////////////////////////////////////////////////////////////////////////
    680 int giet_global_task_id()
    681 {
    682     return sys_call( SYSCALL_GLOBAL_TASK_ID,
    683                      0, 0, 0, 0 );
    684 }
    685 
    686 //////////////////////////////////////////////////////////////////////////////////
    687 // giet_thread_id()
    688 //////////////////////////////////////////////////////////////////////////////////
    689 // This functions returns the thread index of the current task.
    690 //////////////////////////////////////////////////////////////////////////////////
    691 int giet_thread_id()
    692 {
    693     return sys_call( SYSCALL_THREAD_ID,
    694                      0, 0, 0, 0 );
     603/////////////////////////
     604void giet_nic_cma_start()
     605{
     606    if ( sys_call( SYSCALL_NIC_CMA_START, 0, 0, 0, 0 ) ) 
     607       giet_exit("error in giet_nic_cma_start()");
     608}
     609
     610/////////////////////////
     611void giet_nic_cma_stop()
     612{
     613    if ( sys_call( SYSCALL_NIC_CMA_STOP, 0, 0, 0, 0 ) ) 
     614        giet_exit("error in giet_nic_cma_stop()");
    695615}
    696616
    … …  
    699619///////////////////////////////////////////////////////////////////////////////////
    700620
    701 ///////////////////////////////////////////////////////////////////////////////////
    702 // giet_fat_open()
    703 ///////////////////////////////////////////////////////////////////////////////////
    704 // Open a file identified by a pathname, and contained in the system FAT.
    705 // The read/write flags are not supported yet: no effect.
    706 ///////////////////////////////////////////////////////////////////////////////////
     621///////////////////////////////////////////
    707622int giet_fat_open( const char*   pathname,
    708623                   unsigned int  flags )
    … …  
    713628                     0, 0 );
    714629}
     630
     631////////////////////////////////////
     632void giet_fat_read( unsigned int fd,     
     633                    void*        buffer,
     634                    unsigned int count, 
     635                    unsigned int offset )
     636{
     637    if ( sys_call( SYSCALL_FAT_READ,
     638                   fd,
     639                   (unsigned int)buffer,
     640                   count,
     641                   offset ) != count ) giet_exit("in giet_fat_read()");
     642}
     643
     644/////////////////////////////////////
     645void giet_fat_write( unsigned int fd,
     646                     void*        buffer,
     647                     unsigned int count,
     648                     unsigned int offset )
     649{
     650    if ( sys_call( SYSCALL_FAT_WRITE,
     651                   fd,
     652                   (unsigned int)buffer,
     653                   count,
     654                   offset ) != count ) giet_exit("in giet_fat_write()");
     655}
     656
     657/* variant implementing the UNIX spec
    715658///////////////////////////////////////////////////////////////////////////////////
    716 // giet_fat_read()
     659// This system call writes to a file identified by the "fd" file descriptor.
     660// - "buffer" is the source buffer virtual address (must be word aligned).
     661// - "count" is a number of bytes (must be multiple of 4).
     662// It uses the implicit "lseek" pointer in file descriptor.
    717663///////////////////////////////////////////////////////////////////////////////////
    718 // Read "count" sectors from a file identified by "fd", skipping "offset"
    719 // sectors in file, and writing into the user "buffer".
    720 // The user buffer base address shoulb be 64 bytes aligned.
    721 ///////////////////////////////////////////////////////////////////////////////////
    722 // This system call specification should evolve to the UNIX specification:
    723 // - count must be a number of bytes, with no alignment constraint on user buffer.
    724 // - offset argument should be removed and replaced by an implicit "lseek" pointer
    725 //   stored in the file descriptor.
    726 // This suppose to implement a sectors cache
    727 ///////////////////////////////////////////////////////////////////////////////////
    728 int giet_fat_read( unsigned int fd,
    729                    void*        buffer,
    730                    unsigned int count,
    731                    unsigned int offset )
    732 {
    733     return sys_call( SYSCALL_FAT_READ,
    734                      fd,
    735                      (unsigned int)buffer,
    736                      count,
    737                      offset );
    738 }
    739 ///////////////////////////////////////////////////////////////////////////////////
    740 // giet_fat_write()
    741 ///////////////////////////////////////////////////////////////////////////////////
    742 // Write "count" sectors from a file identified by "fd", skipping "offset"
    743 // sectors in file, and reading from the user "buffer".
    744 // The user buffer base address shoulb be 64 bytes aligned.
    745 ///////////////////////////////////////////////////////////////////////////////////
    746 // This system call specification should evolve to the UNIX specification:
    747 // - count must be a number of bytes, with no alignment constraint on buffer
    748 // - offset argument should be removed and replaced by an implicit "lseek" pointer
    749 //   stored in the file descriptor.
    750 // This suppose to implement a sectors cache
    751 ///////////////////////////////////////////////////////////////////////////////////
    752 int giet_fat_write( unsigned int fd,
     664void giet_fat_write( unsigned int fd,
    753665                    void*        buffer,
    754                     unsigned int count,
    755                     unsigned int offset )
     666                    unsigned int count )  // number of bytes
    756667{
    757668    return sys_call( SYSCALL_FAT_WRITE,
    758669                     fd,
    759670                     (unsigned int)buffer,
    760                      count,
    761                      offset );
    762 }
    763 ///////////////////////////////////////////////////////////////////////////////////
    764 // giet_fat_lseek()
    765 ///////////////////////////////////////////////////////////////////////////////////
    766 // Change the lseek file pointer value for a file identified by "fd".
    767 ///////////////////////////////////////////////////////////////////////////////////
    768 int giet_fat_lseek( unsigned int fd,
     671                     count, 0 );
     672}
     673*/
     674
     675/////////////////////////////////////
     676void giet_fat_lseek( unsigned int fd,
    769677                    unsigned int offset,
    770                     unsigned int whence)
    771 {
    772     return sys_call( SYSCALL_FAT_LSEEK,
    773                      fd,
    774                      offset,
    775                      whence,
    776                      0 );
    777 }
    778 
    779 ///////////////////////////////////////////////////////////////////////////////////
    780 // giet_fat_fstat()
    781 ///////////////////////////////////////////////////////////////////////////////////
    782 // Return stats of a file identified by "fd".
    783 // (Only the file_size in sectors for this moment)
    784 ///////////////////////////////////////////////////////////////////////////////////
    785 int giet_fat_fstat( unsigned int fd )
    786 {
    787     return sys_call( SYSCALL_FAT_FSTAT,
    788                      fd,
    789                      0, 0, 0 );
    790 }
    791 
    792 ///////////////////////////////////////////////////////////////////////////////////
    793 // giet_fat_close()
    794 ///////////////////////////////////////////////////////////////////////////////////
    795 // Close a file identified by "fd".
    796 ///////////////////////////////////////////////////////////////////////////////////
    797 int giet_fat_close( unsigned int fd )
    798 {
    799     return sys_call( SYSCALL_FAT_CLOSE,
    800                      fd,
    801                      0, 0, 0 );
    802 }
    803 
    804 
    805 ///////////////////////////////////////////////////////////////////////////////////
    806 ////////////////// Pseudo system calls (no syscall instruction) ///////////////////
    807 ///////////////////////////////////////////////////////////////////////////////////
    808 
    809 ///////////////////////////////////////////////////////////////////////////////////
    810 // giet_rand()
    811 // This function returns a pseudo-random value derived from the processor cycle
    812 // count. This value is comprised between 0 & 65535.
    813 ///////////////////////////////////////////////////////////////////////////////////
     678                    unsigned int whence )
     679{
     680    if ( sys_call( SYSCALL_FAT_LSEEK,
     681                   fd,
     682                   offset,
     683                   whence,
     684                   0 ) ) giet_exit("in giet_fat_lseek()");
     685}
     686
     687//////////////////////////////////////
     688void giet_fat_fstat( unsigned int fd )
     689{
     690    if ( sys_call( SYSCALL_FAT_FSTAT,
     691                   fd,
     692                   0, 0, 0 ) )  giet_exit("in giet_fat_lseek()");
     693}
     694
     695/////////////////////////////////////
     696void giet_fat_close( unsigned int fd )
     697{
     698    if ( sys_call( SYSCALL_FAT_CLOSE,
     699                   fd,
     700                   0, 0, 0 ) )  giet_exit("in giet_fat_close()");
     701}
     702
     703
     704//////////////////////////////////////////////////////////////////////////////////
     705///////////////////// Miscellaneous system calls /////////////////////////////////
     706//////////////////////////////////////////////////////////////////////////////////
     707
     708/////////////////
     709int giet_procid()
     710{
     711    return sys_call( SYSCALL_PROCID,
     712                     0, 0, 0, 0 );
     713}
     714
     715////////////////////
     716int giet_proctime()
     717{
     718    return sys_call( SYSCALL_PROCTIME,
     719                     0, 0, 0, 0 );
     720}
     721
     722///////////////////////
     723int giet_proc_task_id()
     724{
     725    return sys_call( SYSCALL_LOCAL_TASK_ID,
     726                     0, 0, 0, 0 );
     727}
     728
     729/////////////////////////
     730int giet_global_task_id()
     731{
     732    return sys_call( SYSCALL_GLOBAL_TASK_ID,
     733                     0, 0, 0, 0 );
     734}
     735
     736////////////////////
     737int giet_thread_id()
     738{
     739    return sys_call( SYSCALL_THREAD_ID,
     740                     0, 0, 0, 0 );
     741}
     742
     743///////////////
    814744int giet_rand()
    815745{
    … …  
    822752    }
    823753}
     754
     755//////////////////////////////
     756void giet_exit( char* string )
     757{
     758    sys_call( SYSCALL_EXIT,
     759              (unsigned int)string,
     760              0, 0, 0 );
     761}
     762
     763/////////////////////////////////////////
     764void giet_assert( unsigned int condition,
     765                  char*        string )
     766{
     767    if ( condition == 0 ) giet_exit( string );
     768}
     769
     770////////////////////////////////////////////////////
     771void giet_vobj_get_vbase( char*         vspace_name,
     772                          char*         vobj_name,
     773                          unsigned int* vobj_vaddr )
     774{
     775    if ( sys_call( SYSCALL_VOBJ_GET_VBASE,
     776                   (unsigned int) vspace_name,
     777                   (unsigned int) vobj_name,
     778                   (unsigned int) vobj_vaddr,
     779                   0 ) )  giet_exit("in giet_vobj_get_vbase()");
     780}
     781
     782///////////////////////////////////////////////
     783void giet_proc_number( unsigned int  cluster_id,
     784                      unsigned int* buffer )
     785{
     786    if ( sys_call( SYSCALL_PROC_NUMBER,
     787                   cluster_id,
     788                   (unsigned int) buffer,
     789                   0, 0) )  giet_exit("in giet_proc_number()");
     790}
     791
     792//////////////////////////
     793void giet_context_switch()
     794{
     795    sys_call( SYSCALL_CTX_SWITCH,
     796              0, 0, 0, 0 );
     797}
     798
     799/////////////////////////////////////////
     800void giet_heap_info( unsigned int* vaddr,
     801                     unsigned int* length )
     802{
     803    if ( sys_call( SYSCALL_HEAP_INFO,
     804                   (unsigned int)vaddr,
     805                   (unsigned int)length,
     806                   0, 0 ) )  giet_exit("in giet_heap_info()");
     807}
     808
    824809
    825810// Local Variables:

  • soft/giet_vm/giet_libs/stdio.h

    r267 r295  
    1818#define SYSCALL_TIMER_START       0x04
    1919#define SYSCALL_TIMER_STOP        0x05
    20 #define SYSCALL_FREE_06           0x06
    21 #define SYSCALL_FREE_07           0x07
     20#define SYSCALL_TTY_GET_LOCK      0x06
     21#define SYSCALL_TTY_RELEASE_LOCK  0x07
    2222#define SYSCALL_HEAP_INFO         0x08
    2323#define SYSCALL_LOCAL_TASK_ID     0x09
    … …  
    3232#define SYSCALL_FB_SYNC_READ      0x11
    3333#define SYSCALL_THREAD_ID         0x12
    34 #define SYSCALL_TTY_LOCK          0x13
     34#define SYSCALL_FREE_13           0x13
    3535#define SYSCALL_FREE_14           0x14
    3636#define SYSCALL_FREE_15           0x15
    … …  
    9999
    100100//////////////////////////////////////////////////////////////////////////
    101 // MIPS32 related system calls
    102 //////////////////////////////////////////////////////////////////////////
    103 
    104 extern int giet_procid();
    105 
    106 extern int giet_proctime();
    107 
    108 //////////////////////////////////////////////////////////////////////////
    109 // TTY device related system calls
    110 //////////////////////////////////////////////////////////////////////////
    111 
    112 extern int giet_tty_putc(char byte);
    113 
    114 extern int giet_tty_puts(char* buf);
    115 
    116 extern int giet_tty_putw(unsigned int val);
    117 
    118 extern int giet_tty_getc_no_irq(char* byte);
    119 
    120 extern int giet_tty_getc(char* byte);
    121 
    122 extern int giet_tty_gets(char* buf, unsigned int bufsize);
    123 
    124 extern int giet_tty_getw(unsigned int* val);
    125 
    126 extern int giet_tty_printf(char* format,...);
    127 
    128 //////////////////////////////////////////////////////////////////////////
    129 // TIMER device related system calls
    130 //////////////////////////////////////////////////////////////////////////
    131 
    132 extern int giet_timer_start();
    133 
    134 extern int giet_timer_stop();
     101//////////////////////////////////////////////////////////////////////////
     102//               MIPS32 related system calls
     103//////////////////////////////////////////////////////////////////////////
     104//////////////////////////////////////////////////////////////////////////
     105
     106//////////////////////////////////////////////////////////////////////////
     107//////////////////////////////////////////////////////////////////////////
     108//             TTY device related system calls
     109//////////////////////////////////////////////////////////////////////////
     110//////////////////////////////////////////////////////////////////////////
     111
     112//////////////////////////////////////////////////////////////////////////
     113// This function is a modified version of the mutek_printf().
     114// It uses a private terminal allocated to the calling task in the boot.
     115// ("use_tty" argument in xml mapping), and does not take the TTY lock.
     116// It calls several times the _tty_write system function.
     117// Only a limited number of formats are supported:
     118//   - %d : signed decimal
     119//   - %u : unsigned decimal
     120//   - %x : 32 bits hexadecimal
     121//   - %l : 64 bits hexadecimal
     122//   - %c : char
     123//   - %s : string
     124// In case or error returned by syscall, it makes a giet_exit().
     125//////////////////////////////////////////////////////////////////////////
     126extern void giet_tty_printf( char* format, ... );
     127
     128//////////////////////////////////////////////////////////////////////////
     129// This function is a modified version of the mutek_printf().
     130// It uses the kernel TTY0 as a shared terminal, and it takes the
     131// TTY lock to get exclusive access during the format display.
     132// It calls several times the _tty_write system function.
     133// Only a limited number of formats are supported:
     134//   - %d : signed decimal
     135//   - %u : unsigned decimal
     136//   - %x : 32 bits hexadecimal
     137//   - %l : 64 bits hexadecimal
     138//   - %c : char
     139//   - %s : string
     140// In case or error returned by syscall, it makes a giet_exit().
     141//////////////////////////////////////////////////////////////////////////
     142extern void giet_shr_printf( char* format, ... );
     143
     144//////////////////////////////////////////////////////////////////////////
     145// This blocking function fetches a single character from the private
     146// terminal allocated to the calling task in the boot.
     147// It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer.
     148// In case or error returned by syscall, it makes a giet_exit().
     149//////////////////////////////////////////////////////////////////////////
     150extern void giet_tty_getc( char* byte );
     151
     152//////////////////////////////////////////////////////////////////////////
     153// This blocking function fetches a string from the private terminal
     154// allocated to the calling task to a fixed length buffer.
     155// The terminal index must be defined in the task context in the boot.
     156// It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer.
     157// - Up to (bufsize - 1) characters (including the non printable characters)
     158//   are copied into buffer, and the string is completed by a NUL character.
     159// - The <LF> character is interpreted, and the function close the string
     160//   with a NUL character if <LF> is read.
     161// - The <DEL> character is interpreted, and the corresponding character(s)
     162//   are removed from the target buffer.
     163// - It does not provide an echo.
     164// In case or error returned by syscall, it makes a giet_exit().
     165/////////////////////////////////////////////////////////////////////////
     166extern void giet_tty_gets( char* buf, unsigned int bufsize );
     167
     168/////////////////////////////////////////////////////////////////////////
     169// This blocking function fetches a string of decimal characters (most
     170// significant digit first) to build a 32-bit unsigned integer from
     171// the private TTY terminal allocated to the calling task.
     172// The terminal index must be defined in the task context in the boot.
     173// It uses the TTY_RX_IRQ interrupt, and the associated kernel buffer.
     174// - The non-blocking system function _tty_read is called several times,
     175//   and the decimal characters are written in a 32 characters buffer
     176//   until a <LF> character is read.
     177// - It ignores non-decimal characters, and displays an echo
     178//   system function) for each decimal character.
     179// - The <DEL> character is interpreted, and previous characters can be cancelled.
     180// - When the <LF> character is received, the string is converted to an
     181//   unsigned int value. If the number of decimal digit is too large for the 32
     182//   bits range, the zero value is returned.
     183// In case or error returned by syscall, it makes a giet_exit().
     184//////////////////////////////////////////////////////////////////////////
     185extern void giet_tty_getw( unsigned int* val );
     186
     187//////////////////////////////////////////////////////////////////////////
     188//////////////////////////////////////////////////////////////////////////
     189//                TIMER device related system calls
     190//////////////////////////////////////////////////////////////////////////
     191//////////////////////////////////////////////////////////////////////////
     192
     193//////////////////////////////////////////////////////////////////////////
     194// This function activates the private user timer allocated
     195// to the calling task in the boot phase.
     196// In case or error returned by syscall, it makes a giet_exit().
     197//////////////////////////////////////////////////////////////////////////
     198extern void giet_timer_start();
     199
     200//////////////////////////////////////////////////////////////////////////
     201// This function stops the private user timer allocated
     202// to the calling task.
     203// In case or error returned by syscall, it makes a giet_exit().
     204//////////////////////////////////////////////////////////////////////////
     205extern void giet_timer_stop();
    135206 
    136207//////////////////////////////////////////////////////////////////////////
    137 // Frame buffer device related system calls
    138 //////////////////////////////////////////////////////////////////////////
    139 
    140 extern int giet_fb_sync_read( unsigned int offset,
    141                               void*        buffer,
     208//////////////////////////////////////////////////////////////////////////
     209//                Frame buffer device related system calls
     210//////////////////////////////////////////////////////////////////////////
     211//////////////////////////////////////////////////////////////////////////
     212
     213//////////////////////////////////////////////////////////////////////////
     214// This blocking function use a memory copy strategy to transfer data
     215// from the frame buffer device in kernel space to an user buffer.
     216//     offset : offset (in bytes) in the frame buffer
     217//     buffer : base address of the user buffer
     218//     length : number of bytes to be transfered
     219// In case or error returned by syscall, it makes a giet_exit().
     220//////////////////////////////////////////////////////////////////////////
     221extern void giet_fb_sync_read( unsigned int offset,
     222                               void*        buffer,
     223                               unsigned int length );
     224
     225//////////////////////////////////////////////////////////////////////////
     226// This blocking function use a memory copy strategy to transfer data
     227// from a user buffer to the frame buffer device in kernel space.
     228//     offset : offset (in bytes) in the frame buffer
     229//     buffer : base address of the memory buffer
     230//     length : number of bytes to be transfered
     231// In case or error returned by syscall, it makes a giet_exit().
     232//////////////////////////////////////////////////////////////////////////
     233extern void giet_fb_sync_write( unsigned int offset,
     234                                void*        buffer,
     235                                unsigned int length );
     236
     237//////////////////////////////////////////////////////////////////////////
     238// This function initializes the two chbuf SRC an DST used by the CMA
     239// controller and activates the CMA channel allocated to the calling task.
     240// - buf0   : first user buffer virtual address
     241// - buf1   : second user buffer virtual address
     242// - length : buffer size (bytes)
     243// In case or error returned by syscall, it makes a giet_exit().
     244//////////////////////////////////////////////////////////////////////////
     245extern void giet_fb_cma_init( void*        buf0,
     246                              void*        buf1,
    142247                              unsigned int length );
    143248
    144 extern int giet_fb_sync_write(unsigned int offset,
    145                               void*        buffer,
    146                               unsigned int length);
    147 
    148 extern int giet_fb_cma_init(  void*        buf0,
    149                               void*        buf1,
    150                               unsigned int length);
    151 
    152 extern int giet_fb_cma_write(unsigned int buf_id);
    153 
    154 extern int giet_fb_cma_stop();
    155 
    156 //////////////////////////////////////////////////////////////////////////
    157 // Network controller related system calls
    158 //////////////////////////////////////////////////////////////////////////
    159 
    160 extern int giet_nic_cma_start();
    161 
    162 extern int giet_nic_cma_stop();
    163 
    164 //////////////////////////////////////////////////////////////////////////
    165 // FAT related system calls
    166 //////////////////////////////////////////////////////////////////////////
    167 
     249//////////////////////////////////////////////////////////////////////////
     250// This function initializes the two chbuf SRC an DST used by the CMA
     251// controller and activates the CMA channel allocated to the calling task.
     252// - buf0   : first user buffer virtual address
     253// - buf0   : second user buffer virtual address
     254// - length : buffer size (bytes)
     255// In case or error returned by syscall, it makes a giet_exit().
     256//////////////////////////////////////////////////////////////////////////
     257extern void giet_fb_cma_write( unsigned int buf_id );
     258
     259//////////////////////////////////////////////////////////////////////////
     260// This function desactivates the CMA channel allocated to the task.
     261// In case or error returned by syscall, it makes a giet_exit().
     262//////////////////////////////////////////////////////////////////////////
     263extern void giet_fb_cma_stop();
     264
     265//////////////////////////////////////////////////////////////////////////
     266//////////////////////////////////////////////////////////////////////////
     267//                  NIC related system calls
     268//////////////////////////////////////////////////////////////////////////
     269//////////////////////////////////////////////////////////////////////////
     270
     271//////////////////////////////////////////////////////////////////////////
     272// This function initializes the memory chbuf used by the CMA controller,
     273// activates the NIC channel allocated to the calling task,
     274// and activates the two CMA channels.
     275// - tx     : RX channel if 0 / TX channel if non 0
     276// - buf0   : first user buffer virtual address
     277// - buf1   : second user buffer virtual address
     278// - length : buffer size (bytes)
     279// In case or error returned by syscall, it makes a giet_exit().
     280//////////////////////////////////////////////////////////////////////////
     281extern void giet_nic_cma_start();
     282
     283//////////////////////////////////////////////////////////////////////////
     284// This function desactivates the NIC channel and the two CMA channels
     285// allocated to the calling task.
     286// In case or error returned by syscall, it makes a giet_exit().
     287//////////////////////////////////////////////////////////////////////////
     288extern void giet_nic_cma_stop();
     289
     290//////////////////////////////////////////////////////////////////////////
     291//////////////////////////////////////////////////////////////////////////
     292//               FAT related system calls
     293//////////////////////////////////////////////////////////////////////////
     294//////////////////////////////////////////////////////////////////////////
     295
     296//////////////////////////////////////////////////////////////////////////
     297// Open a file identified by a pathname, and contained in the system FAT.
     298// The read/write flags are not supported yet: no effect.
     299// Return -1 in case or error.
     300//////////////////////////////////////////////////////////////////////////
    168301extern int giet_fat_open(  const char*  pathname,
    169302                           unsigned int flags );
    170303
    171 extern int giet_fat_read(  unsigned int fd,
    172                            void*        buffer,
    173                            unsigned int count,
    174                            unsigned int offset );
    175 
    176 extern int giet_fat_write( unsigned int fd,
    177                            void*        buffer,
    178                            unsigned int count,
    179                            unsigned int offset );
    180 
    181 extern int giet_fat_lseek( unsigned int fd,
    182                            unsigned int offset,
    183                            unsigned int whence );
    184 
    185 extern int giet_fat_fstat( unsigned int fd );
    186 
    187 extern int giet_fat_close( unsigned int fd );
    188 
    189 //////////////////////////////////////////////////////////////////////////
    190 // Miscelaneous system calls
    191 //////////////////////////////////////////////////////////////////////////
    192 
    193 extern int giet_vobj_get_vbase( char*         vspace_name,
    194                                 char*         vobj_name,
    195                                 unsigned int  vobj_type,
    196                                 unsigned int* vobj_vaddr);
    197 
    198 extern int giet_procnumber();
    199 
     304///////////////////////////////////////////////////////////////////////////////////
     305// Read "count" sectors from a file identified by "fd", skipping "offset"
     306// sectors in file, and writing into the user "buffer".
     307// The user buffer base address shoulb be 64 bytes aligned.
     308// In case or error returned by syscall, it makes a giet_exit().
     309///////////////////////////////////////////////////////////////////////////////////
     310extern void giet_fat_read(  unsigned int fd,
     311                            void*        buffer,
     312                            unsigned int count,
     313                            unsigned int offset );
     314
     315///////////////////////////////////////////////////////////////////////////////////
     316// Write "count" sectors from a file identified by "fd", skipping "offset"
     317// sectors in file, and reading from the user "buffer".
     318// The user buffer base address shoulb be 64 bytes aligned.
     319// In case or error returned by syscall, it makes a giet_exit().
     320///////////////////////////////////////////////////////////////////////////////////
     321extern void giet_fat_write( unsigned int fd,
     322                            void*        buffer,
     323                            unsigned int count,
     324                            unsigned int offset );
     325
     326///////////////////////////////////////////////////////////////////////////////////
     327// Change the lseek file pointer value for a file identified by "fd".
     328// In case or error returned by syscall, it makes a giet_exit().
     329///////////////////////////////////////////////////////////////////////////////////
     330extern void giet_fat_lseek( unsigned int fd,
     331                            unsigned int offset,
     332                            unsigned int whence );
     333
     334///////////////////////////////////////////////////////////////////////////////////
     335// Returns general informations of a file identified by "fd".
     336// (Only the file_size in sectors for this moment)
     337///////////////////////////////////////////////////////////////////////////////////
     338extern void giet_fat_fstat( unsigned int fd );
     339
     340//////////////////////////////////////////////////////////////////////////
     341// Close a file identified by "fd".
     342//////////////////////////////////////////////////////////////////////////
     343extern void giet_fat_close( unsigned int fd );
     344
     345//////////////////////////////////////////////////////////////////////////
     346//////////////////////////////////////////////////////////////////////////
     347//                    Miscelaneous system calls
     348//////////////////////////////////////////////////////////////////////////
     349//////////////////////////////////////////////////////////////////////////
     350
     351//////////////////////////////////////////////////////////////////////////
     352// This function returns the processor identifier.
     353//////////////////////////////////////////////////////////////////////////
     354extern int giet_procid();
     355
     356//////////////////////////////////////////////////////////////////////////
     357// This function returns the local processor time.
     358//////////////////////////////////////////////////////////////////////////
     359extern int giet_proctime();
     360
     361//////////////////////////////////////////////////////////////////////////
     362// This functions returns the local task id.
     363// If processor has n tasks the local task index is ranging from 0 to n-1
     364//////////////////////////////////////////////////////////////////////////
     365extern int giet_proc_task_id();
     366
     367//////////////////////////////////////////////////////////////////////////
     368// This functions returns the global task id, (unique in the system).
     369//////////////////////////////////////////////////////////////////////////
     370extern int giet_global_task_id();
     371
     372//////////////////////////////////////////////////////////////////////////
     373// This functions returns the thread index of the task in its vspace.
     374//////////////////////////////////////////////////////////////////////////
     375extern int giet_thread_id();
     376
     377//////////////////////////////////////////////////////////////////////////
     378// This function returns a pseudo-random value derived from the processor
     379// cycle count. This value is comprised between 0 & 65535.
     380/////////////////////////////////////////////////////////////////////////
     381extern int giet_rand();
     382
     383//////////////////////////////////////////////////////////////////////////
     384// This function stops execution of the calling task with a TTY message,
     385// the user task is descheduled and becomes not runable.
     386// It does not consume processor cycles anymore.
     387//////////////////////////////////////////////////////////////////////////
    200388extern void giet_exit();
    201389
    202 extern int giet_context_switch();
    203 
    204 extern int giet_proc_task_id();
    205 
    206 extern int giet_heap_info( unsigned int* vaddr,
    207                            unsigned int* size );
    208 
    209 extern int giet_global_task_id();
    210 
    211 extern int giet_thread_id();
    212 
     390//////////////////////////////////////////////////////////////////////////
     391// This function uses the giet_exit() system call
     392// and kill the calling task if the condition is false.
     393//////////////////////////////////////////////////////////////////////////
    213394extern void giet_assert( unsigned int,
    214395                         char* string );
    215396
    216 extern int giet_rand();
     397//////////////////////////////////////////////////////////////////////////
     398// This function writes in argument "vobj_vaddr" the virtual base address
     399// of a vobj (defined in the mapping_info data structure), identified by
     400// the two arguments "vspace_name" and "vobj_name".
     401// In case or error returned by syscall, it makes a giet_exit().
     402// ( vobj not defined or wrong vspace )
     403//////////////////////////////////////////////////////////////////////////
     404extern void giet_vobj_get_vbase( char*         vspace_name,
     405                                 char*         vobj_name,
     406                                 unsigned int* vobj_vaddr);
     407
     408//////////////////////////////////////////////////////////////////////////
     409// This function returns in the "buffer" argument the number of processors
     410// in the cluster specified by the "cluster_xy" argument.
     411// In case or error returned by syscall, it makes a giet_exit().
     412//////////////////////////////////////////////////////////////////////////
     413extern void giet_procnumber( unsigned int cluster_xy,
     414                             unsigned int buffer );
     415
     416//////////////////////////////////////////////////////////////////////////
     417// The user task calling this function is descheduled and
     418// the processor is allocated to another task.
     419//////////////////////////////////////////////////////////////////////////
     420extern void giet_context_switch();
     421
     422//////////////////////////////////////////////////////////////////////////
     423// This function returns the base address and size of the task's heap
     424//////////////////////////////////////////////////////////////////////////
     425extern void giet_heap_info( unsigned int* vaddr,
     426                            unsigned int* size );
     427
    217428
    218429#endif
Note: See TracChangeset for help on using the changeset viewer.