source: soft/giet_vm/giet_libs/stdio.c @ 681

Last change on this file since 681 was 671, checked in by alain, 9 years ago

Introduce the "shared" argument in the giet_tty_alloc() system call.
  • Property svn:executable set to *
File size: 35.3 KB
Line 
1//////////////////////////////////////////////////////////////////////////////
2// File     : stdio.c         
3// Date     : 01/04/2010
4// Author   : alain greiner & Joel Porquet
5// Copyright (c) UPMC-LIP6
6//////////////////////////////////////////////////////////////////////////////
7
8#include <stdarg.h>
9#include <stdio.h>
10#include <giet_config.h>
11
12//////////////////////////////////////////////////////////////////////////////
13/////////////////////  MIPS32     related system calls ///////////////////////
14//////////////////////////////////////////////////////////////////////////////
15
16////////////////////////////////////////////
17void giet_proc_xyp( unsigned int* cluster_x,
18                    unsigned int* cluster_y,
19                    unsigned int* lpid )
20{
21    sys_call( SYSCALL_PROC_XYP,
22              (unsigned int)cluster_x,
23              (unsigned int)cluster_y,
24              (unsigned int)lpid,
25               0 );
26}
27
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);
40    if ((x & 0xF) > 7) 
41    {
42        return (x*x & 0xFFFF);
43    }
44    else 
45    {
46        return (x*x*x & 0xFFFF);
47    }
48}
49
50//////////////////////////////////////////////////////////////////////////////
51///////////////////// Task related  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
75//////////////////////////////
76void giet_exit( char* string ) 
77{
78    sys_call( SYSCALL_EXIT,
79              (unsigned int)string,
80              0, 0, 0 );
81}
82
83/////////////////////////////////////////
84void giet_assert( unsigned int condition,
85                  char*        string )
86{
87    if ( condition == 0 ) giet_exit( string );
88}
89
90//////////////////////////
91void giet_context_switch() 
92{
93    sys_call( SYSCALL_CTX_SWITCH,
94              0, 0, 0, 0 );
95}
96
97//////////////////////////////////////////////////////////////////////////////
98///////////////////// Applications  system calls /////////////////////////////
99//////////////////////////////////////////////////////////////////////////////
100
101///////////////////////////////////////
102int giet_kill_application( char* name ) 
103{
104    return ( sys_call( SYSCALL_KILL_APP,
105                       (unsigned int)name,
106                       0, 0, 0 ) );
107}
108
109///////////////////////////////////////
110int giet_exec_application( char* name ) 
111{
112    return ( sys_call( SYSCALL_EXEC_APP,
113                       (unsigned int)name,
114                       0, 0, 0 ) );
115}
116
117//////////////////////////////////////////////////////////////////////////////
118///////////////////// Coprocessors  system calls  ////////////////////////////
119//////////////////////////////////////////////////////////////////////////////
120
121///////////////////////////////////////////////////
122void giet_coproc_alloc( unsigned int   coproc_type,
123                        unsigned int*  coproc_info )
124{
125    if ( sys_call( SYSCALL_COPROC_ALLOC,
126                   coproc_type,
127                   (unsigned int)coproc_info,
128                   0, 0 ) ) 
129        giet_exit("error in giet_coproc_alloc()");
130}
131
132/////////////////////////////////////////////////////////
133void giet_coproc_release( unsigned int coproc_reg_index )
134{
135    if ( sys_call( SYSCALL_COPROC_RELEASE,
136                   coproc_reg_index,
137                   0, 0, 0 ) ) 
138        giet_exit("error in giet_coproc_release()");
139}
140
141//////////////////////////////////////////////////////////////////
142void giet_coproc_channel_init( unsigned int            channel,
143                               giet_coproc_channel_t*  desc )
144{
145    if ( sys_call( SYSCALL_COPROC_CHANNEL_INIT,
146                   channel,
147                   (unsigned int)desc,
148                   0, 0 ) ) 
149        giet_exit("error in giet_coproc_channel_init()");
150}
151
152/////////////////////////////////////////////////////
153void giet_coproc_run( unsigned int coproc_reg_index )
154{
155    if ( sys_call( SYSCALL_COPROC_RUN,
156                   coproc_reg_index,
157                   0, 0, 0 ) ) 
158        giet_exit("error in giet_coproc_run()");
159}
160
161////////////////////////////
162void giet_coproc_completed()
163{
164    if ( sys_call( SYSCALL_COPROC_COMPLETED,
165                   0, 0, 0, 0 ) ) 
166        giet_exit("error in giet_coproc_completed");
167}
168
169
170//////////////////////////////////////////////////////////////////////////////
171/////////////////////  TTY device related system calls ///////////////////////
172//////////////////////////////////////////////////////////////////////////////
173
174//////////////////////////////////////////
175void giet_tty_alloc( unsigned int shared )
176{
177    if ( sys_call( SYSCALL_TTY_ALLOC,
178                   shared,
179                   0, 0, 0 ) )  giet_exit("error in giet_tty_alloc()");
180}
181
182////////////////////////////////////////////////////////////////////////
183static  int __printf( char* format, unsigned int channel, va_list* args) 
184{
185    int ret;                    // return value from the syscall
186    enum TModifiers {NO_MOD, L_MOD, LL_MOD} modifiers;
187
188printf_text:
189
190    while (*format) 
191    {
192        unsigned int i;
193        for (i = 0 ; format[i] && (format[i] != '%') ; i++);
194        if (i) 
195        {
196            ret = sys_call(SYSCALL_TTY_WRITE, 
197                           (unsigned int)format,
198                           i, 
199                           channel,
200                           0);
201
202            if (ret != i) goto return_error;
203
204            format += i;
205        }
206        if (*format == '%') 
207        {
208            format++;
209            modifiers = NO_MOD;
210            goto printf_arguments;
211        }
212    }
213
214    return 0;
215
216printf_arguments:
217
218    {
219        char              buf[30];
220        char *            pbuf;
221        unsigned int      len = 0;
222        static const char HexaTab[] = "0123456789ABCDEF";
223        unsigned int      i;
224       
225        /* Ignored fields : width and precision */
226        for (; *format >= '0' && *format <= '9'; format++);
227
228        switch (*format++) 
229        {
230            case ('%'):
231            {
232                len = 1;
233                pbuf = "%";
234                break;
235            }
236            case ('c'):             /* char conversion */
237            {
238                int val = va_arg( *args, int );
239                if (modifiers != NO_MOD) goto return_error; // Modifiers have no meaning
240               
241                len = 1;
242                buf[0] = val;
243                pbuf = &buf[0];
244                break;
245            }
246            case ('d'):             /* decimal signed integer */
247            {
248                int val = va_arg( *args, int );
249               
250                if (modifiers == LL_MOD) goto return_error; // 64 bits not supported
251               
252                if (val < 0) 
253                {
254                    val = -val;
255                    ret = sys_call(SYSCALL_TTY_WRITE, 
256                                   (unsigned int)"-",
257                                   1,
258                                   channel,
259                                   0);
260                    if (ret != 1) goto return_error;
261                }
262                for(i = 0; i < 10; i++) 
263                {
264                    buf[9 - i] = HexaTab[val % 10];
265                    if (!(val /= 10)) break;
266                }
267                len =  i + 1;
268                pbuf = &buf[9 - i];
269                break;
270            }
271            case ('u'):             /* decimal unsigned integer */
272            {
273                if (modifiers != LL_MOD) //32 bits integer
274                {
275                    unsigned int val = va_arg( *args, unsigned int );
276                    for(i = 0; i < 10; i++) 
277                    {
278                        buf[9 - i] = HexaTab[val % 10];
279                        if (!(val /= 10)) break;
280                    }
281                    len =  i + 1;
282                    pbuf = &buf[9 - i];
283                    break;
284                }
285                //64 bits : base 10 unsupported : continue to hexa
286            }
287            case ('x'):
288            case ('X'):             /* hexadecimal integer */
289            {
290                unsigned long long val;
291                int imax;
292               
293                if (modifiers == LL_MOD) // 64 bits
294                {
295                    val = va_arg( *args, unsigned long long);
296                   
297                    // if asked to print in base 10, can do only if it fits in 32 bits
298                    if (*(format-1) == 'u' && (!(val & 0xFFFFFFFF00000000ULL))) 
299                    {
300                        unsigned int uintv = (unsigned int) val;
301                       
302                        for(i = 0; i < 10; i++) 
303                        {
304                            buf[9 - i] = HexaTab[uintv % 10];
305                            if (!(uintv /= 10)) break;
306                        }
307                        len =  i + 1;
308                        pbuf = &buf[9 - i];
309                        break;
310                    }
311                   
312                    imax = 16;
313                }
314                else //32 bits
315                {
316                    val = va_arg( *args, unsigned int);
317                    imax = 8;
318                }
319               
320                ret = sys_call(SYSCALL_TTY_WRITE,
321                               (unsigned int)"0x",
322                               2,
323                               channel,
324                               0);
325                if (ret != 2) goto return_error;
326               
327                for(i = 0; i < imax; i++) 
328                {
329                    buf[(imax-1) - i] = HexaTab[val % 16];
330                    if (!(val /= 16))  break;
331                }
332                len =  i + 1;
333                pbuf = &buf[(imax-1) - i];
334                break;
335            }
336            case ('s'):             /* string */
337            {
338                char* str = va_arg( *args, char* );
339               
340                if (modifiers != NO_MOD) goto return_error; // Modifiers have no meaning
341               
342                while (str[len]) 
343                {
344                    len++;
345                }
346                pbuf = str;
347                break;
348            }
349            case ('e'):
350            case ('f'):
351            case ('g'):             /* IEEE754 64 bits */
352            {
353                union
354                {
355                    double d;
356                    unsigned long long ull;
357                } val;
358               
359                val.d = va_arg( *args, double );
360               
361                unsigned long long digits = val.ull & 0xFFFFFFFFFFFFFULL;    //get mantissa
362               
363                unsigned int
364                    base = (unsigned int)((val.ull & 0x7FF0000000000000ULL) >> 52), //get exposant
365                    intp = (unsigned int)val.d,         //get integer part of the float
366                    decp;
367               
368                int isvalue = 0;
369               
370                if (base == 0x7FF) //special value
371                {
372                    if (digits & 0xFFFFFFFFFFFFFULL)
373                    {
374                        /* Not a Number */
375                        buf[0] = 'N';
376                        buf[1] = 'a';
377                        buf[2] = 'N';
378                        len = 3;
379                        pbuf = buf;
380                    }
381                    else
382                    {
383                        /* inf */
384                        buf[0] = (val.ull & 0x8000000000000000ULL) ? '-' : '+';
385                        buf[1] = 'i';
386                        buf[2] = 'n';
387                        buf[3] = 'f';
388                        len = 4;
389                        pbuf = buf;
390                    }
391                    break;
392                }
393               
394                if (val.ull & 0x8000000000000000ULL)
395                {
396                    /* negative */
397                    ret = sys_call(SYSCALL_TTY_WRITE,
398                                (unsigned int)"-",
399                                1,
400                                channel,
401                                0);
402                    if (ret != 1) goto return_error;
403                    val.d = val.d * -1;
404                }
405                else
406                {
407                    /* positive */
408                    ret = sys_call(SYSCALL_TTY_WRITE,
409                                (unsigned int)"+",
410                                1,
411                                channel,
412                                0);
413                    if (ret != 1) goto return_error;
414                }
415               
416                if (val.d > 0xFFFFFFFF)
417                {
418                    /* overflow */
419                    buf[0] = 'B';
420                    buf[1] = 'I';
421                    buf[2] = 'G';
422                    len = 3;
423                    pbuf = buf;
424                    break;
425                }
426               
427                val.d -= (double)intp;
428                decp = (unsigned int)(val.d * 1000000000);
429               
430                for(i = 0; i < 10; i++) 
431                {
432                    if ((!isvalue) && (intp % 10)) isvalue = 1;
433                    buf[9 - i] = HexaTab[intp % 10];
434                    if (!(intp /= 10)) break;
435                }
436                pbuf = &buf[9 - i];
437                len = i+11;
438                buf[10] = '.';
439               
440                for(i = 0; i < 9; i++)
441                {
442                    if ((!isvalue) && (decp % 10)) isvalue = 1;
443                    buf[19 - i] = HexaTab[decp % 10];
444                    decp /= 10;
445                }
446               
447                if (!isvalue)
448                {
449                    if (val.d != 0)
450                    {
451                        /* underflow */
452                        buf[0] = 'T';
453                        buf[1] = 'I';
454                        buf[2] = 'N';
455                        buf[3] = 'Y';
456                        len = 4;
457                        pbuf = buf;
458                    }
459                }
460
461                break;
462            }
463            case ('l'):
464                switch (modifiers)
465                {
466                    case NO_MOD:
467                        modifiers = L_MOD;
468                        goto printf_arguments;
469                   
470                    case L_MOD:
471                        modifiers = LL_MOD;
472                        goto printf_arguments;
473                   
474                    default:
475                        goto return_error;
476                }
477
478            /* Ignored fields : width and precision */
479            case ('.'): goto printf_arguments;
480               
481            default:
482                goto return_error;
483        }
484
485        ret = sys_call(SYSCALL_TTY_WRITE, 
486                       (unsigned int)pbuf,
487                       len,
488                       channel, 
489                       0);
490        if (ret != len)  goto return_error;
491       
492        goto printf_text;
493    }
494
495return_error:
496    return 1;
497} // end __printf()
498
499
500////////////////////////////////////////
501void giet_tty_printf( char* format, ...) 
502{
503    va_list args;
504
505    va_start( args, format );
506    int ret = __printf(format, 0xFFFFFFFF, &args);
507    va_end( args );
508
509    if (ret)
510    {
511        giet_exit("ERROR in giet_tty_printf()");
512    }
513} // end giet_tty_printf()
514
515////////////////////////////////////////
516void giet_shr_printf( char* format, ...) 
517{
518    va_list args;
519    volatile unsigned int sr_save;
520
521    sys_call( SYSCALL_TTY_GET_LOCK,
522              0,
523              (unsigned int)&sr_save,
524              0, 0 );
525
526    va_start( args, format );
527    int ret = __printf(format, 0, &args);
528    va_end( args );
529
530    sys_call( SYSCALL_TTY_RELEASE_LOCK,
531              0,
532              (unsigned int)&sr_save,
533              0, 0 );
534
535    if (ret)
536    {
537        giet_exit("error in giet_shr_printf()");
538    }
539} // end giet_shr_printf()
540
541/////////////////////////////////
542void giet_tty_getc( char * byte ) 
543{
544    int ret;
545
546    do
547    {
548        ret = sys_call(SYSCALL_TTY_READ, 
549                      (unsigned int)byte,  // buffer address
550                      1,                   // number of characters
551                      0xFFFFFFFF,          // channel index from task context
552                      0);
553        if ( ret < 0 ) giet_exit("error in giet_tty_getc()");
554    }
555    while (ret != 1); 
556}
557
558/////////////////////////////////////
559void giet_tty_gets( char*        buf, 
560                    unsigned int bufsize ) 
561{
562    int           ret;                           // return value from syscalls
563    unsigned char byte;
564    unsigned int  index = 0;
565    unsigned int  string_cancel = 0x00082008;    // string containing BS/SPACE/BS
566 
567    while (index < (bufsize - 1)) 
568    {
569        // get one character
570        do 
571        { 
572            ret = sys_call(SYSCALL_TTY_READ, 
573                           (unsigned int)(&byte),
574                           1,
575                           0xFFFFFFFF,        // channel index from task context
576                           0);
577            if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
578        } 
579        while (ret != 1);
580
581        // analyse character
582        if (byte == 0x0A)                          // LF  special character
583        {
584            break; 
585        }
586        else if ( (byte == 0x7F) ||                // DEL special character
587                  (byte == 0x08) )                 // BS  special character
588        {
589            if ( index > 0 )     
590            {
591                index--; 
592
593                // cancel character
594                ret = sys_call( SYSCALL_TTY_WRITE,
595                                (unsigned int)(&string_cancel),
596                                3,
597                                0XFFFFFFFF,        // channel index from task context
598                                0 );
599                if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
600            }
601        }
602        else if ( (byte < 0x20) || (byte > 0x7F) )  // non printable characters
603        {
604        }
605        else                                       // take all other characters
606        {
607            buf[index] = byte;
608            index++;
609
610            // echo
611            ret = sys_call( SYSCALL_TTY_WRITE,
612                            (unsigned int)(&byte),
613                            1,
614                            0XFFFFFFFF,        // channel index from task context
615                            0 );
616            if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
617     
618        }
619    }
620    buf[index] = 0;
621
622}   // end giet_tty_gets()
623
624///////////////////////////////////////
625void giet_tty_getw( unsigned int* val ) 
626{
627    unsigned char buf[32];
628    unsigned int  string_byte   = 0x00000000;    // string containing one single byte
629    unsigned int  string_cancel = 0x00082008;    // string containing BS/SPACE/BS
630    unsigned int  save = 0;
631    unsigned int  dec = 0;
632    unsigned int  done = 0;
633    unsigned int  overflow = 0;
634    unsigned int  length = 0;
635    unsigned int  i;
636    int           ret;      // return value from syscalls
637 
638    // get characters
639    while (done == 0) 
640    {
641        // read one character
642        do 
643        { 
644            ret = sys_call( SYSCALL_TTY_READ,
645                            (unsigned int)(&string_byte),
646                            1,
647                            0xFFFFFFFF,    // channel index from task context
648                            0); 
649            if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
650        } 
651        while (ret != 1);
652
653        // analyse character
654        if ((string_byte > 0x2F) && (string_byte < 0x3A))  // decimal character
655        {
656            buf[length] = (unsigned char)string_byte;
657            length++;
658
659            // echo
660            ret = sys_call( SYSCALL_TTY_WRITE, 
661                            (unsigned int)(&string_byte),
662                            1, 
663                            0xFFFFFFFF,    // channel index from task context
664                            0 );
665            if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
666        }
667        else if (string_byte == 0x0A)                     // LF character
668        {
669            done = 1;
670        }
671        else if ( (string_byte == 0x7F) ||                // DEL character
672                  (string_byte == 0x08) )                 // BS  character
673        {
674            if ( length > 0 ) 
675            {
676                length--;    // cancel the character
677
678                ret = sys_call( SYSCALL_TTY_WRITE, 
679                                (unsigned int)(&string_cancel),
680                                3, 
681                                0xFFFFFFFF,    // channel index from task context
682                                0 );
683                if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
684            }
685        }
686
687        // test buffer overflow
688        if ( length >= 32 ) 
689        {
690            overflow = 1;
691            done     = 1;
692        }
693    }  // end while characters
694
695    // string to int conversion with overflow detection
696    if ( overflow == 0 )
697    {
698        for (i = 0; (i < length) && (overflow == 0) ; i++) 
699        {
700            dec = dec * 10 + (buf[i] - 0x30);
701            if (dec < save)  overflow = 1; 
702            save = dec;
703        }
704    } 
705
706    // final evaluation
707    if ( overflow == 0 )
708    {
709        // return value
710        *val = dec;
711    }
712    else
713    {
714        // cancel all echo characters
715        for (i = 0; i < length ; i++) 
716        {
717            ret = sys_call( SYSCALL_TTY_WRITE, 
718                            (unsigned int)(&string_cancel),
719                            3, 
720                            0xFFFFFFFF,    // channel index from task context
721                            0 );
722            if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
723        }
724        // echo character '0'
725        string_byte = 0x30;
726        ret = sys_call( SYSCALL_TTY_WRITE, 
727                        (unsigned int)(&string_byte),
728                        1, 
729                        0xFFFFFFFF,    // channel index from task context
730                        0 );
731        if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
732
733        // return 0 value
734        *val = 0;
735    }
736}   // end giet_tty_getw()
737
738
739//////////////////////////////////////////////////////////////////////////////////
740/////////////////////  TIMER related system calls ////////////////////////////////
741//////////////////////////////////////////////////////////////////////////////////
742
743///////////////////////
744void giet_timer_alloc() 
745{
746    if ( sys_call( SYSCALL_TIM_ALLOC,
747                   0, 0, 0, 0 ) ) giet_exit("error in giet_timer_alloc()");
748}
749
750////////////////////////////////////////////
751void giet_timer_start( unsigned int period ) 
752{
753    if ( sys_call( SYSCALL_TIM_START,
754                   period,
755                   0, 0, 0 ) ) giet_exit("error in giet_timer_start()");
756}
757
758//////////////////////
759void giet_timer_stop() 
760{
761    if ( sys_call( SYSCALL_TIM_STOP,
762                   0, 0, 0, 0 ) ) giet_exit("error in giet_timer_stop()");
763}
764
765
766//////////////////////////////////////////////////////////////////////////////////
767///////////////  Frame buffer device related system calls  ///////////////////////
768//////////////////////////////////////////////////////////////////////////////////
769
770/////////////////////////
771void giet_fbf_cma_alloc()
772{
773    if ( sys_call( SYSCALL_FBF_CMA_ALLOC, 
774                   0, 0, 0, 0 ) )    giet_exit("error in giet_fbf_cma_alloc()");
775}
776
777///////////////////////////////////////////
778void giet_fbf_cma_init_buf( void* buf0_vbase, 
779                            void* buf1_vbase,
780                            void* sts0_vaddr,
781                            void* sts1_vaddr )
782{
783    if ( sys_call( SYSCALL_FBF_CMA_INIT_BUF,
784                   (unsigned int)buf0_vbase, 
785                   (unsigned int)buf1_vbase,
786                   (unsigned int)sts0_vaddr, 
787                   (unsigned int)sts1_vaddr ) )   giet_exit("error in giet_fbf_cma_init_buf()");
788}
789
790///////////////////////////////////////////
791void giet_fbf_cma_start( unsigned int length )
792{
793    if ( sys_call( SYSCALL_FBF_CMA_START,
794                   length, 
795                   0, 0, 0 ) )   giet_exit("error in giet_fbf_cma_start()");
796}
797
798////////////////////////////////////////////////
799void giet_fbf_cma_display( unsigned int buffer )
800{
801    if ( sys_call( SYSCALL_FBF_CMA_DISPLAY,
802                   buffer, 
803                   0, 0, 0 ) )   giet_exit("error in giet_fbf_cma_display()");
804}
805
806////////////////////////
807void giet_fbf_cma_stop()
808{
809    if ( sys_call( SYSCALL_FBF_CMA_STOP, 
810                   0, 0, 0, 0 ) )    giet_exit("error in giet_fbf_cma_stop()");
811}
812
813//////////////////////////////////////////////
814void giet_fbf_sync_write( unsigned int offset, 
815                          void *       buffer, 
816                          unsigned int length ) 
817{
818    if ( sys_call( SYSCALL_FBF_SYNC_WRITE, 
819                   offset, 
820                   (unsigned int)buffer, 
821                   length, 
822                   0 ) )  giet_exit("error in giet_fbf_sync_write()");
823}
824
825/////////////////////////////////////////////
826void giet_fbf_sync_read( unsigned int offset, 
827                         void *       buffer, 
828                         unsigned int length ) 
829{
830    if ( sys_call( SYSCALL_FBF_SYNC_READ, 
831                   offset, 
832                   (unsigned int)buffer, 
833                   length, 
834                   0 ) )   giet_exit("error in giet_fbf_sync_read()");
835}
836
837
838//////////////////////////////////////////////////////////////////////////////////
839/////////////////////// NIC related system calls /////////////////////////////////
840//////////////////////////////////////////////////////////////////////////////////
841
842////////////////////////////////////////////////////
843unsigned int giet_nic_rx_alloc( unsigned int xmax,
844                                unsigned int ymax )
845{
846    int channel = sys_call( SYSCALL_NIC_ALLOC,
847                            1, 
848                            xmax,
849                            ymax,
850                            0 );
851    if ( channel < 0 ) giet_exit("error in giet_nic_rx_alloc()");
852
853    return (unsigned int)channel;
854}
855
856////////////////////////////////////////////////////
857unsigned int giet_nic_tx_alloc( unsigned int xmax,
858                                unsigned int ymax )
859{
860    int channel = sys_call( SYSCALL_NIC_ALLOC,
861                            0,
862                            xmax,
863                            ymax,
864                            0 );
865    if ( channel < 0 ) giet_exit("error in giet_nic_tx_alloc()");
866
867    return (unsigned int)channel;
868}
869
870//////////////////////////////////////////////
871void giet_nic_rx_start( unsigned int channel )
872{
873    if ( sys_call( SYSCALL_NIC_START,
874                   1,
875                   channel,
876                   0, 0 ) ) giet_exit("error in giet_nic_rx_start()");
877}
878
879//////////////////////////////////////////////
880void giet_nic_tx_start( unsigned int channel )
881{
882    if ( sys_call( SYSCALL_NIC_START,
883                   0, 
884                   channel,
885                   0, 0 ) ) giet_exit("error in giet_nic_tx_start()");
886}
887
888///////////////////////////////////////////////////////////
889void giet_nic_rx_move( unsigned int channel, void* buffer )
890{
891    if ( sys_call( SYSCALL_NIC_MOVE,
892                   1,
893                   channel, 
894                   (unsigned int)buffer,
895                   0 ) )  giet_exit("error in giet_nic_rx_move()");
896}
897
898///////////////////////////////////////////////////////////
899void giet_nic_tx_move( unsigned int channel, void* buffer )
900{
901    if ( sys_call( SYSCALL_NIC_MOVE,
902                   0,
903                   channel, 
904                   (unsigned int)buffer,
905                   0 ) )  giet_exit("error in giet_nic_tx_move()");
906}
907
908/////////////////////////////////////////////
909void giet_nic_rx_stop( unsigned int channel )
910{
911    if ( sys_call( SYSCALL_NIC_STOP,
912                   1, 
913                   channel,
914                   0, 0 ) ) giet_exit("error in giet_nic_rx_stop()");
915}
916
917/////////////////////////////////////////////
918void giet_nic_tx_stop( unsigned int channel )
919{
920    if ( sys_call( SYSCALL_NIC_STOP,
921                   0, 
922                   channel,
923                   0, 0 ) ) giet_exit("error in giet_nic_tx_stop()");
924}
925
926//////////////////////////////////////////////
927void giet_nic_rx_stats( unsigned int channel )
928{
929    if ( sys_call( SYSCALL_NIC_STATS,
930                   1, 
931                   channel,
932                   0, 0 ) ) giet_exit("error in giet_nic_rx_stats()");
933}
934
935//////////////////////////////////////////////
936void giet_nic_tx_stats( unsigned int channel )
937{
938    if ( sys_call( SYSCALL_NIC_STATS,
939                   0, 
940                   channel,
941                   0, 0 ) ) giet_exit("error in giet_nic_tx_stats()");
942}
943
944//////////////////////////////////////////////
945void giet_nic_rx_clear( unsigned int channel )
946{
947    if ( sys_call( SYSCALL_NIC_CLEAR,
948                   1, 
949                   channel,
950                   0, 0 ) ) giet_exit("error in giet_nic_rx_clear()");
951}
952
953//////////////////////////////////////////////
954void giet_nic_tx_clear( unsigned int channel )
955{
956    if ( sys_call( SYSCALL_NIC_CLEAR,
957                   0, 
958                   channel,
959                   0, 0 ) ) giet_exit("error in giet_nic_tx_clear()");
960}
961
962
963
964///////////////////////////////////////////////////////////////////////////////////
965///////////////////// FAT related system calls ////////////////////////////////////
966///////////////////////////////////////////////////////////////////////////////////
967
968/////////////////////////////////////////
969int giet_fat_open( char*        pathname,
970                   unsigned int flags ) 
971{
972    return  sys_call( SYSCALL_FAT_OPEN, 
973                      (unsigned int)pathname, 
974                      flags,
975                      0, 0 );
976}
977
978/////////////////////////////////////////
979int giet_fat_close( unsigned int fd_id )
980{
981    return  sys_call( SYSCALL_FAT_CLOSE,
982                      fd_id,
983                      0, 0, 0 );
984}
985
986/////////////////////////////////////////////
987int giet_fat_file_info( unsigned int            fd_id,
988                        struct fat_file_info_s* info )
989{
990    return sys_call( SYSCALL_FAT_FINFO,
991                     fd_id,
992                     (unsigned int)info,
993                     0, 0 );
994}
995
996///////////////////////////////////////
997int giet_fat_read( unsigned int fd_id,     
998                   void*        buffer, 
999                   unsigned int count ) 
1000{
1001    return sys_call( SYSCALL_FAT_READ,
1002                     fd_id,
1003                     (unsigned int)buffer,
1004                     count,
1005                     0 ); 
1006}
1007
1008////////////////////////////////////////
1009int giet_fat_write( unsigned int fd_id,
1010                    void*        buffer, 
1011                    unsigned int count )
1012{
1013    return sys_call( SYSCALL_FAT_WRITE, 
1014                     fd_id, 
1015                     (unsigned int)buffer,
1016                     count,
1017                     0 ); 
1018}
1019
1020////////////////////////////////////////
1021int giet_fat_lseek( unsigned int fd_id,
1022                    unsigned int offset, 
1023                    unsigned int whence )
1024{
1025    return sys_call( SYSCALL_FAT_LSEEK, 
1026                     fd_id, 
1027                     offset, 
1028                     whence,
1029                     0 ); 
1030}
1031
1032////////////////////////////////////////////
1033int giet_fat_remove( char*         pathname,
1034                     unsigned int  should_be_dir )
1035{
1036    return sys_call( SYSCALL_FAT_REMOVE,
1037                     (unsigned int)pathname,
1038                      should_be_dir,
1039                      0, 0 );
1040}
1041
1042/////////////////////////////////////
1043int giet_fat_rename( char*  old_path,
1044                     char*  new_path )
1045{
1046    return sys_call( SYSCALL_FAT_RENAME,
1047                     (unsigned int)old_path,
1048                     (unsigned int)new_path,
1049                      0, 0 );
1050}
1051
1052////////////////////////////////////
1053int giet_fat_mkdir( char* pathname )
1054{
1055    return sys_call( SYSCALL_FAT_MKDIR,
1056                     (unsigned int)pathname,
1057                      0, 0, 0 );
1058}
1059
1060////////////////////////////////////
1061int giet_fat_opendir( char* pathname )
1062{
1063    return sys_call( SYSCALL_FAT_OPENDIR,
1064                     (unsigned int)pathname,
1065                     0, 0, 0 );
1066}
1067
1068////////////////////////////////////
1069int giet_fat_closedir( unsigned int fd_id )
1070{
1071    return sys_call( SYSCALL_FAT_CLOSEDIR,
1072                     (unsigned int)fd_id,
1073                     0, 0, 0 );
1074}
1075
1076////////////////////////////////////
1077int giet_fat_readdir( unsigned int  fd_id,
1078                      fat_dirent_t* entry )
1079{
1080    return sys_call( SYSCALL_FAT_READDIR,
1081                     (unsigned int)fd_id,
1082                     (unsigned int)entry,
1083                     0, 0 );
1084}
1085
1086
1087
1088//////////////////////////////////////////////////////////////////////////////////
1089///////////////////// Miscellaneous system calls /////////////////////////////////
1090//////////////////////////////////////////////////////////////////////////////////
1091
1092/////////////////////////////////////////////////
1093void giet_procs_number( unsigned int* x_size, 
1094                        unsigned int* y_size,
1095                        unsigned int* nprocs ) 
1096{
1097    if ( sys_call( SYSCALL_PROCS_NUMBER, 
1098                   (unsigned int)x_size, 
1099                   (unsigned int)y_size, 
1100                   (unsigned int)nprocs, 
1101                   0 ) )  giet_exit("ERROR in giet_procs_number()");
1102}
1103
1104////////////////////////////////////////////////////
1105void giet_vobj_get_vbase( char*         vspace_name, 
1106                          char*         vobj_name, 
1107                          unsigned int* vbase ) 
1108{
1109    if ( sys_call( SYSCALL_VOBJ_GET_VBASE, 
1110                   (unsigned int) vspace_name,
1111                   (unsigned int) vobj_name,
1112                   (unsigned int) vbase,
1113                   0 ) )  giet_exit("ERROR in giet_vobj_get_vbase()");
1114}
1115
1116////////////////////////////////////////////////////
1117void giet_vobj_get_length( char*         vspace_name, 
1118                           char*         vobj_name, 
1119                           unsigned int* length ) 
1120{
1121    if ( sys_call( SYSCALL_VOBJ_GET_LENGTH, 
1122                   (unsigned int) vspace_name,
1123                   (unsigned int) vobj_name,
1124                   (unsigned int) length,
1125                   0 ) )  giet_exit("ERROR in giet_vobj_get_length()");
1126}
1127
1128/////////////////////////////////////////
1129void giet_heap_info( unsigned int* vaddr, 
1130                     unsigned int* length,
1131                     unsigned int  x,
1132                     unsigned int  y ) 
1133{
1134    if ( sys_call( SYSCALL_HEAP_INFO, 
1135                   (unsigned int)vaddr, 
1136                   (unsigned int)length, 
1137                   x,
1138                   y ) )  giet_exit("ERROR in giet_heap_info()");
1139}
1140
1141/////////////////////////////////////////
1142void giet_get_xy( void*         ptr,
1143                  unsigned int* px,
1144                  unsigned int* py )
1145{
1146    if ( sys_call( SYSCALL_GET_XY,
1147                   (unsigned int)ptr,
1148                   (unsigned int)px,
1149                   (unsigned int)py,
1150                   0 ) )  giet_exit("ERROR in giet_get_xy()");
1151}
1152
1153// Local Variables:
1154// tab-width: 4
1155// c-basic-offset: 4
1156// c-file-offsets:((innamespace . 0)(inline-open . 0))
1157// indent-tabs-mode: nil
1158// End:
1159// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
1160
Note: See TracBrowser for help on using the repository browser.