[743] | 1 | ///////////////////////////////////////////////////////////////////////////////////// |
---|
[258] | 2 | // File : stdio.c |
---|
| 3 | // Date : 01/04/2010 |
---|
| 4 | // Author : alain greiner & Joel Porquet |
---|
| 5 | // Copyright (c) UPMC-LIP6 |
---|
[743] | 6 | ///////////////////////////////////////////////////////////////////////////////////// |
---|
[258] | 7 | |
---|
| 8 | #include <stdarg.h> |
---|
| 9 | #include <stdio.h> |
---|
[771] | 10 | #include <stdlib.h> |
---|
[267] | 11 | #include <giet_config.h> |
---|
[258] | 12 | |
---|
[743] | 13 | |
---|
[521] | 14 | ////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 15 | // MIPS32 related system calls |
---|
[521] | 16 | ////////////////////////////////////////////////////////////////////////////// |
---|
[390] | 17 | |
---|
[438] | 18 | //////////////////////////////////////////// |
---|
[431] | 19 | void giet_proc_xyp( unsigned int* cluster_x, |
---|
| 20 | unsigned int* cluster_y, |
---|
| 21 | unsigned int* lpid ) |
---|
[390] | 22 | { |
---|
[438] | 23 | sys_call( SYSCALL_PROC_XYP, |
---|
[431] | 24 | (unsigned int)cluster_x, |
---|
| 25 | (unsigned int)cluster_y, |
---|
| 26 | (unsigned int)lpid, |
---|
| 27 | 0 ); |
---|
[390] | 28 | } |
---|
| 29 | |
---|
[438] | 30 | //////////////////////////// |
---|
| 31 | unsigned int giet_proctime() |
---|
[390] | 32 | { |
---|
[438] | 33 | return (unsigned int)sys_call( SYSCALL_PROC_TIME, |
---|
| 34 | 0, 0, 0, 0 ); |
---|
[390] | 35 | } |
---|
| 36 | |
---|
[438] | 37 | //////////////////////// |
---|
| 38 | unsigned int giet_rand() |
---|
[390] | 39 | { |
---|
[438] | 40 | unsigned int x = (unsigned int)sys_call( SYSCALL_PROC_TIME, |
---|
| 41 | 0, 0, 0, 0); |
---|
[390] | 42 | if ((x & 0xF) > 7) |
---|
| 43 | { |
---|
| 44 | return (x*x & 0xFFFF); |
---|
| 45 | } |
---|
| 46 | else |
---|
| 47 | { |
---|
| 48 | return (x*x*x & 0xFFFF); |
---|
| 49 | } |
---|
| 50 | } |
---|
| 51 | |
---|
[521] | 52 | ////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 53 | // Threads related system calls |
---|
[521] | 54 | ////////////////////////////////////////////////////////////////////////////// |
---|
[438] | 55 | |
---|
[709] | 56 | #define THREAD_CMD_PAUSE 0 |
---|
| 57 | #define THREAD_CMD_RESUME 1 |
---|
| 58 | #define THREAD_CMD_CONTEXT 2 |
---|
| 59 | |
---|
| 60 | ////////////////////////////////////////////////////////// |
---|
| 61 | int giet_pthread_create( pthread_t* buffer, |
---|
| 62 | pthread_attr_t* attr, |
---|
| 63 | void* function, |
---|
| 64 | void* arg ) |
---|
[438] | 65 | { |
---|
[709] | 66 | return sys_call( SYSCALL_PTHREAD_CREATE, |
---|
| 67 | (unsigned int)buffer, |
---|
| 68 | (unsigned int)attr, |
---|
| 69 | (unsigned int)function, |
---|
| 70 | (unsigned int)arg ); |
---|
| 71 | } |
---|
| 72 | |
---|
| 73 | ////////////////////////////////////// |
---|
| 74 | void giet_pthread_exit( void* string ) |
---|
| 75 | { |
---|
| 76 | sys_call( SYSCALL_PTHREAD_EXIT, |
---|
| 77 | (unsigned int)string, |
---|
| 78 | 0, 0, 0 ); |
---|
[438] | 79 | } |
---|
| 80 | |
---|
[709] | 81 | //////////////////////////////////////// |
---|
| 82 | int giet_pthread_join( pthread_t trdid, |
---|
| 83 | void** ptr ) |
---|
[438] | 84 | { |
---|
[709] | 85 | return sys_call( SYSCALL_PTHREAD_JOIN, |
---|
| 86 | trdid, |
---|
| 87 | (unsigned int)ptr, |
---|
| 88 | 0, 0 ); |
---|
[438] | 89 | } |
---|
| 90 | |
---|
[709] | 91 | /////////////////////////////////////// |
---|
| 92 | int giet_pthread_kill( pthread_t trdid, |
---|
| 93 | int signal ) |
---|
[438] | 94 | { |
---|
[709] | 95 | return sys_call( SYSCALL_PTHREAD_KILL, |
---|
| 96 | trdid, |
---|
| 97 | signal, |
---|
| 98 | 0, 0 ); |
---|
[438] | 99 | } |
---|
| 100 | |
---|
[709] | 101 | ///////////////////////// |
---|
| 102 | void giet_pthread_yield() |
---|
[647] | 103 | { |
---|
[709] | 104 | sys_call( SYSCALL_PTHREAD_YIELD, |
---|
| 105 | 0, 0, 0, 0 ); |
---|
[647] | 106 | } |
---|
[438] | 107 | |
---|
[709] | 108 | ///////////////////////////////////////////////// |
---|
| 109 | void giet_pthread_assert( unsigned int condition, |
---|
| 110 | char* string ) |
---|
[647] | 111 | { |
---|
[709] | 112 | if ( condition == 0 ) giet_pthread_exit( string ); |
---|
[647] | 113 | } |
---|
| 114 | |
---|
[713] | 115 | //////////////////////////////////////////////// |
---|
| 116 | void giet_pthread_control( unsigned int command, |
---|
| 117 | char* vspace_name, |
---|
| 118 | char* thread_name ) |
---|
[647] | 119 | { |
---|
[713] | 120 | int ret = sys_call( SYSCALL_PTHREAD_CONTROL, |
---|
| 121 | command, |
---|
| 122 | (unsigned int) vspace_name, |
---|
| 123 | (unsigned int) thread_name, |
---|
| 124 | 0 ); |
---|
[647] | 125 | |
---|
[713] | 126 | if ( ret == SYSCALL_VSPACE_NOT_FOUND ) |
---|
| 127 | { |
---|
| 128 | giet_tty_printf(" ERROR in PTHREAD_CONTROL : " |
---|
| 129 | "vspace %s not found\n", vspace_name ); |
---|
| 130 | } |
---|
| 131 | if ( ret == SYSCALL_THREAD_NOT_FOUND ) |
---|
| 132 | { |
---|
| 133 | giet_tty_printf(" ERROR in PTHREAD_CONTROL : " |
---|
| 134 | "thread %s not found\n", thread_name ); |
---|
| 135 | } |
---|
| 136 | if ( ret == SYSCALL_UNCOHERENT_THREAD_CONTEXT ) |
---|
| 137 | { |
---|
| 138 | giet_tty_printf(" ERROR in PTHREAD_CONTROL : " |
---|
| 139 | "uncoherent context for thread %s\n", thread_name ); |
---|
| 140 | } |
---|
| 141 | if ( ret == SYSCALL_ILLEGAL_THREAD_COMMAND_TYPE ) |
---|
| 142 | { |
---|
| 143 | giet_tty_printf(" ERROR in PTHREAD_CONTROL : " |
---|
| 144 | "illegal command type %d\n", command ); |
---|
| 145 | } |
---|
[689] | 146 | } |
---|
| 147 | |
---|
[709] | 148 | |
---|
[521] | 149 | ////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 150 | // Applications related system calls |
---|
[647] | 151 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 152 | |
---|
| 153 | /////////////////////////////////////// |
---|
| 154 | int giet_kill_application( char* name ) |
---|
| 155 | { |
---|
| 156 | return ( sys_call( SYSCALL_KILL_APP, |
---|
| 157 | (unsigned int)name, |
---|
| 158 | 0, 0, 0 ) ); |
---|
| 159 | } |
---|
| 160 | |
---|
| 161 | /////////////////////////////////////// |
---|
| 162 | int giet_exec_application( char* name ) |
---|
| 163 | { |
---|
| 164 | return ( sys_call( SYSCALL_EXEC_APP, |
---|
| 165 | (unsigned int)name, |
---|
| 166 | 0, 0, 0 ) ); |
---|
| 167 | } |
---|
| 168 | |
---|
[713] | 169 | /////////////////////////////////////////// |
---|
| 170 | void giet_applications_status( char* name ) |
---|
[709] | 171 | { |
---|
| 172 | sys_call( SYSCALL_APPS_STATUS, |
---|
[713] | 173 | (unsigned int)name, |
---|
| 174 | 0, 0, 0 ); |
---|
[709] | 175 | } |
---|
| 176 | |
---|
[647] | 177 | ////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 178 | // Coprocessors related system calls |
---|
[521] | 179 | ////////////////////////////////////////////////////////////////////////////// |
---|
[295] | 180 | |
---|
[521] | 181 | /////////////////////////////////////////////////// |
---|
[735] | 182 | void giet_coproc_alloc( unsigned int cluster_xy, |
---|
| 183 | unsigned int coproc_type, |
---|
[558] | 184 | unsigned int* coproc_info ) |
---|
[521] | 185 | { |
---|
| 186 | if ( sys_call( SYSCALL_COPROC_ALLOC, |
---|
[735] | 187 | cluster_xy, |
---|
[521] | 188 | coproc_type, |
---|
| 189 | (unsigned int)coproc_info, |
---|
[735] | 190 | 0 ) ) |
---|
[709] | 191 | giet_pthread_exit("error in giet_coproc_alloc()"); |
---|
[521] | 192 | } |
---|
| 193 | |
---|
[735] | 194 | ////////////////////////////////////////////////// |
---|
| 195 | void giet_coproc_release( unsigned int cluster_xy, |
---|
| 196 | unsigned int coproc_type ) |
---|
[521] | 197 | { |
---|
| 198 | if ( sys_call( SYSCALL_COPROC_RELEASE, |
---|
[735] | 199 | cluster_xy, |
---|
| 200 | coproc_type, |
---|
| 201 | 0 , 0 ) ) |
---|
[709] | 202 | giet_pthread_exit("error in giet_coproc_release()"); |
---|
[521] | 203 | } |
---|
| 204 | |
---|
| 205 | ////////////////////////////////////////////////////////////////// |
---|
[735] | 206 | void giet_coproc_channel_init( unsigned int cluster_xy, |
---|
| 207 | unsigned int coproc_type, |
---|
| 208 | unsigned int channel, |
---|
[521] | 209 | giet_coproc_channel_t* desc ) |
---|
| 210 | { |
---|
| 211 | if ( sys_call( SYSCALL_COPROC_CHANNEL_INIT, |
---|
[735] | 212 | cluster_xy, |
---|
| 213 | coproc_type, |
---|
[521] | 214 | channel, |
---|
[735] | 215 | (unsigned int)desc ) ) |
---|
[709] | 216 | giet_pthread_exit("error in giet_coproc_channel_init()"); |
---|
[521] | 217 | } |
---|
| 218 | |
---|
[735] | 219 | ////////////////////////////////////////////// |
---|
| 220 | void giet_coproc_run( unsigned int cluster_xy, |
---|
| 221 | unsigned int coproc_type ) |
---|
[521] | 222 | { |
---|
[558] | 223 | if ( sys_call( SYSCALL_COPROC_RUN, |
---|
[735] | 224 | cluster_xy, |
---|
| 225 | coproc_type, |
---|
| 226 | 0 , 0 ) ) |
---|
[709] | 227 | giet_pthread_exit("error in giet_coproc_run()"); |
---|
[521] | 228 | } |
---|
| 229 | |
---|
[735] | 230 | //////////////////////////////////////////////////// |
---|
| 231 | void giet_coproc_completed( unsigned int cluster_xy, |
---|
| 232 | unsigned int coproc_type ) |
---|
[521] | 233 | { |
---|
| 234 | if ( sys_call( SYSCALL_COPROC_COMPLETED, |
---|
[735] | 235 | cluster_xy, |
---|
| 236 | coproc_type, |
---|
| 237 | 0 , 0 ) ) |
---|
[709] | 238 | giet_pthread_exit("error in giet_coproc_completed"); |
---|
[521] | 239 | } |
---|
| 240 | |
---|
| 241 | |
---|
| 242 | ////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 243 | // TTY device related system calls |
---|
[521] | 244 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 245 | |
---|
[671] | 246 | ////////////////////////////////////////// |
---|
| 247 | void giet_tty_alloc( unsigned int shared ) |
---|
[258] | 248 | { |
---|
[521] | 249 | if ( sys_call( SYSCALL_TTY_ALLOC, |
---|
[671] | 250 | shared, |
---|
[709] | 251 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_tty_alloc()"); |
---|
[743] | 252 | } |
---|
[258] | 253 | |
---|
[345] | 254 | //////////////////////////////////////// |
---|
| 255 | void giet_tty_printf( char* format, ...) |
---|
| 256 | { |
---|
[743] | 257 | va_list args; |
---|
[771] | 258 | char string[4096]; |
---|
[743] | 259 | unsigned int length; |
---|
[345] | 260 | |
---|
| 261 | va_start( args, format ); |
---|
[771] | 262 | length = xprintf( string , 4096 , format , &args ); |
---|
[295] | 263 | va_end( args ); |
---|
[345] | 264 | |
---|
[743] | 265 | if ( length == 0xFFFFFFFF ) giet_pthread_exit("illegal format in giet_tty_printf()"); |
---|
| 266 | |
---|
| 267 | if ( sys_call( SYSCALL_TTY_WRITE, |
---|
[771] | 268 | (unsigned int)string, // buffer address |
---|
[743] | 269 | length, // number of characters |
---|
| 270 | 0xFFFFFFFF, // channel index from thread context |
---|
| 271 | 0) != length ) giet_pthread_exit("error in giet_tty_printf()"); |
---|
[295] | 272 | |
---|
[743] | 273 | } |
---|
| 274 | |
---|
[295] | 275 | ///////////////////////////////// |
---|
| 276 | void giet_tty_getc( char * byte ) |
---|
| 277 | { |
---|
| 278 | int ret; |
---|
| 279 | |
---|
| 280 | do |
---|
[267] | 281 | { |
---|
[295] | 282 | ret = sys_call(SYSCALL_TTY_READ, |
---|
| 283 | (unsigned int)byte, // buffer address |
---|
| 284 | 1, // number of characters |
---|
| 285 | 0xFFFFFFFF, // channel index from task context |
---|
| 286 | 0); |
---|
[709] | 287 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_getc()"); |
---|
[267] | 288 | } |
---|
[295] | 289 | while (ret != 1); |
---|
| 290 | } |
---|
[267] | 291 | |
---|
[295] | 292 | ///////////////////////////////////// |
---|
| 293 | void giet_tty_gets( char* buf, |
---|
| 294 | unsigned int bufsize ) |
---|
| 295 | { |
---|
[647] | 296 | int ret; // return value from syscalls |
---|
[295] | 297 | unsigned char byte; |
---|
| 298 | unsigned int index = 0; |
---|
[647] | 299 | unsigned int string_cancel = 0x00082008; // string containing BS/SPACE/BS |
---|
[295] | 300 | |
---|
| 301 | while (index < (bufsize - 1)) |
---|
| 302 | { |
---|
[647] | 303 | // get one character |
---|
[295] | 304 | do |
---|
| 305 | { |
---|
| 306 | ret = sys_call(SYSCALL_TTY_READ, |
---|
| 307 | (unsigned int)(&byte), |
---|
| 308 | 1, |
---|
[647] | 309 | 0xFFFFFFFF, // channel index from task context |
---|
[295] | 310 | 0); |
---|
[709] | 311 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_gets()"); |
---|
[295] | 312 | } |
---|
| 313 | while (ret != 1); |
---|
| 314 | |
---|
[647] | 315 | // analyse character |
---|
| 316 | if (byte == 0x0A) // LF special character |
---|
[295] | 317 | { |
---|
| 318 | break; |
---|
| 319 | } |
---|
[647] | 320 | else if ( (byte == 0x7F) || // DEL special character |
---|
| 321 | (byte == 0x08) ) // BS special character |
---|
[295] | 322 | { |
---|
[647] | 323 | if ( index > 0 ) |
---|
| 324 | { |
---|
| 325 | index--; |
---|
| 326 | |
---|
| 327 | // cancel character |
---|
| 328 | ret = sys_call( SYSCALL_TTY_WRITE, |
---|
| 329 | (unsigned int)(&string_cancel), |
---|
| 330 | 3, |
---|
| 331 | 0XFFFFFFFF, // channel index from task context |
---|
| 332 | 0 ); |
---|
[709] | 333 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_gets()"); |
---|
[647] | 334 | } |
---|
[295] | 335 | } |
---|
[647] | 336 | else if ( (byte < 0x20) || (byte > 0x7F) ) // non printable characters |
---|
[295] | 337 | { |
---|
[647] | 338 | } |
---|
| 339 | else // take all other characters |
---|
| 340 | { |
---|
[295] | 341 | buf[index] = byte; |
---|
| 342 | index++; |
---|
[647] | 343 | |
---|
| 344 | // echo |
---|
| 345 | ret = sys_call( SYSCALL_TTY_WRITE, |
---|
| 346 | (unsigned int)(&byte), |
---|
| 347 | 1, |
---|
| 348 | 0XFFFFFFFF, // channel index from task context |
---|
| 349 | 0 ); |
---|
[709] | 350 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_gets()"); |
---|
[647] | 351 | |
---|
[295] | 352 | } |
---|
| 353 | } |
---|
| 354 | buf[index] = 0; |
---|
[258] | 355 | |
---|
[743] | 356 | } |
---|
[647] | 357 | |
---|
[295] | 358 | /////////////////////////////////////// |
---|
| 359 | void giet_tty_getw( unsigned int* val ) |
---|
| 360 | { |
---|
| 361 | unsigned char buf[32]; |
---|
| 362 | unsigned int string_byte = 0x00000000; // string containing one single byte |
---|
| 363 | unsigned int string_cancel = 0x00082008; // string containing BS/SPACE/BS |
---|
| 364 | unsigned int save = 0; |
---|
| 365 | unsigned int dec = 0; |
---|
| 366 | unsigned int done = 0; |
---|
| 367 | unsigned int overflow = 0; |
---|
| 368 | unsigned int length = 0; |
---|
| 369 | unsigned int i; |
---|
| 370 | int ret; // return value from syscalls |
---|
| 371 | |
---|
| 372 | // get characters |
---|
| 373 | while (done == 0) |
---|
| 374 | { |
---|
| 375 | // read one character |
---|
| 376 | do |
---|
| 377 | { |
---|
| 378 | ret = sys_call( SYSCALL_TTY_READ, |
---|
| 379 | (unsigned int)(&string_byte), |
---|
| 380 | 1, |
---|
[647] | 381 | 0xFFFFFFFF, // channel index from task context |
---|
[295] | 382 | 0); |
---|
[709] | 383 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_getw()"); |
---|
[295] | 384 | } |
---|
| 385 | while (ret != 1); |
---|
[258] | 386 | |
---|
[295] | 387 | // analyse character |
---|
[647] | 388 | if ((string_byte > 0x2F) && (string_byte < 0x3A)) // decimal character |
---|
[295] | 389 | { |
---|
| 390 | buf[length] = (unsigned char)string_byte; |
---|
| 391 | length++; |
---|
[258] | 392 | |
---|
[295] | 393 | // echo |
---|
| 394 | ret = sys_call( SYSCALL_TTY_WRITE, |
---|
| 395 | (unsigned int)(&string_byte), |
---|
| 396 | 1, |
---|
[647] | 397 | 0xFFFFFFFF, // channel index from task context |
---|
[295] | 398 | 0 ); |
---|
[709] | 399 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_getw()"); |
---|
[295] | 400 | } |
---|
[647] | 401 | else if (string_byte == 0x0A) // LF character |
---|
[295] | 402 | { |
---|
| 403 | done = 1; |
---|
| 404 | } |
---|
[647] | 405 | else if ( (string_byte == 0x7F) || // DEL character |
---|
| 406 | (string_byte == 0x08) ) // BS character |
---|
[295] | 407 | { |
---|
| 408 | if ( length > 0 ) |
---|
| 409 | { |
---|
| 410 | length--; // cancel the character |
---|
| 411 | |
---|
| 412 | ret = sys_call( SYSCALL_TTY_WRITE, |
---|
| 413 | (unsigned int)(&string_cancel), |
---|
| 414 | 3, |
---|
[647] | 415 | 0xFFFFFFFF, // channel index from task context |
---|
[295] | 416 | 0 ); |
---|
[709] | 417 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_getw()"); |
---|
[295] | 418 | } |
---|
| 419 | } |
---|
| 420 | |
---|
| 421 | // test buffer overflow |
---|
| 422 | if ( length >= 32 ) |
---|
| 423 | { |
---|
| 424 | overflow = 1; |
---|
| 425 | done = 1; |
---|
| 426 | } |
---|
| 427 | } // end while characters |
---|
| 428 | |
---|
| 429 | // string to int conversion with overflow detection |
---|
| 430 | if ( overflow == 0 ) |
---|
| 431 | { |
---|
| 432 | for (i = 0; (i < length) && (overflow == 0) ; i++) |
---|
| 433 | { |
---|
| 434 | dec = dec * 10 + (buf[i] - 0x30); |
---|
| 435 | if (dec < save) overflow = 1; |
---|
| 436 | save = dec; |
---|
| 437 | } |
---|
| 438 | } |
---|
| 439 | |
---|
| 440 | // final evaluation |
---|
| 441 | if ( overflow == 0 ) |
---|
| 442 | { |
---|
| 443 | // return value |
---|
| 444 | *val = dec; |
---|
| 445 | } |
---|
| 446 | else |
---|
| 447 | { |
---|
| 448 | // cancel all echo characters |
---|
| 449 | for (i = 0; i < length ; i++) |
---|
| 450 | { |
---|
| 451 | ret = sys_call( SYSCALL_TTY_WRITE, |
---|
| 452 | (unsigned int)(&string_cancel), |
---|
| 453 | 3, |
---|
[647] | 454 | 0xFFFFFFFF, // channel index from task context |
---|
[295] | 455 | 0 ); |
---|
[709] | 456 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_getw()"); |
---|
[295] | 457 | } |
---|
| 458 | // echo character '0' |
---|
| 459 | string_byte = 0x30; |
---|
| 460 | ret = sys_call( SYSCALL_TTY_WRITE, |
---|
| 461 | (unsigned int)(&string_byte), |
---|
| 462 | 1, |
---|
[647] | 463 | 0xFFFFFFFF, // channel index from task context |
---|
[295] | 464 | 0 ); |
---|
[709] | 465 | if ( ret < 0 ) giet_pthread_exit("error in giet_tty_getw()"); |
---|
[295] | 466 | |
---|
| 467 | // return 0 value |
---|
| 468 | *val = 0; |
---|
| 469 | } |
---|
[743] | 470 | } |
---|
[295] | 471 | |
---|
| 472 | |
---|
[258] | 473 | ////////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 474 | // TIMER related system calls |
---|
[258] | 475 | ////////////////////////////////////////////////////////////////////////////////// |
---|
| 476 | |
---|
[295] | 477 | /////////////////////// |
---|
[438] | 478 | void giet_timer_alloc() |
---|
[258] | 479 | { |
---|
[438] | 480 | if ( sys_call( SYSCALL_TIM_ALLOC, |
---|
[713] | 481 | 0, 0, 0, 0 ) ) giet_pthread_exit("ERROR in TIMER_ALLOC"); |
---|
[258] | 482 | } |
---|
[295] | 483 | |
---|
[438] | 484 | //////////////////////////////////////////// |
---|
| 485 | void giet_timer_start( unsigned int period ) |
---|
| 486 | { |
---|
| 487 | if ( sys_call( SYSCALL_TIM_START, |
---|
| 488 | period, |
---|
[713] | 489 | 0, 0, 0 ) ) giet_pthread_exit("ERROR in TIMER_START"); |
---|
[438] | 490 | } |
---|
| 491 | |
---|
[295] | 492 | ////////////////////// |
---|
| 493 | void giet_timer_stop() |
---|
[258] | 494 | { |
---|
[438] | 495 | if ( sys_call( SYSCALL_TIM_STOP, |
---|
[713] | 496 | 0, 0, 0, 0 ) ) giet_pthread_exit("ERROR in TIMER_STOP"); |
---|
[258] | 497 | } |
---|
| 498 | |
---|
| 499 | |
---|
| 500 | ////////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 501 | // Frame buffer related system calls |
---|
[258] | 502 | ////////////////////////////////////////////////////////////////////////////////// |
---|
| 503 | |
---|
[713] | 504 | //////////////////////////////////////// |
---|
| 505 | void giet_fbf_size( unsigned int* width, |
---|
| 506 | unsigned int* height ) |
---|
| 507 | { |
---|
| 508 | sys_call( SYSCALL_FBF_SIZE, |
---|
| 509 | (unsigned int)width, |
---|
| 510 | (unsigned int)height, |
---|
| 511 | 0, 0 ); |
---|
| 512 | } |
---|
| 513 | |
---|
| 514 | ///////////////////// |
---|
| 515 | void giet_fbf_alloc() |
---|
| 516 | { |
---|
| 517 | if ( sys_call( SYSCALL_FBF_ALLOC, |
---|
| 518 | 0, 0, 0, 0 ) ) giet_pthread_exit("ERROR in FBF_ALLOC"); |
---|
| 519 | } |
---|
| 520 | |
---|
[722] | 521 | //////////////////////////////////////////// |
---|
| 522 | void giet_fbf_cma_alloc( unsigned int nbufs ) |
---|
[258] | 523 | { |
---|
[438] | 524 | if ( sys_call( SYSCALL_FBF_CMA_ALLOC, |
---|
[722] | 525 | nbufs, |
---|
| 526 | 0, 0, 0 ) ) giet_pthread_exit("ERROR in FBF_CMA_ALLOC"); |
---|
[258] | 527 | } |
---|
[295] | 528 | |
---|
[722] | 529 | /////////////////////////////////////////////// |
---|
| 530 | void giet_fbf_cma_init_buf( unsigned int index, |
---|
| 531 | void* buf_vaddr, |
---|
| 532 | void* sts_vaddr ) |
---|
[258] | 533 | { |
---|
[614] | 534 | if ( sys_call( SYSCALL_FBF_CMA_INIT_BUF, |
---|
[722] | 535 | index, |
---|
| 536 | (unsigned int)buf_vaddr, |
---|
| 537 | (unsigned int)sts_vaddr, |
---|
| 538 | 0 ) ) giet_pthread_exit("ERROR in FBF_CMA_INIT_BUF"); |
---|
[614] | 539 | } |
---|
| 540 | |
---|
[722] | 541 | ///////////////////////// |
---|
| 542 | void giet_fbf_cma_start() |
---|
[614] | 543 | { |
---|
[438] | 544 | if ( sys_call( SYSCALL_FBF_CMA_START, |
---|
[722] | 545 | 0, 0, 0, 0 ) ) giet_pthread_exit("ERROR in FBF_CMA_START"); |
---|
[258] | 546 | } |
---|
[295] | 547 | |
---|
[722] | 548 | /////////////////////////////////////////////// |
---|
| 549 | void giet_fbf_cma_display( unsigned int index ) |
---|
[258] | 550 | { |
---|
[438] | 551 | if ( sys_call( SYSCALL_FBF_CMA_DISPLAY, |
---|
[722] | 552 | index, |
---|
[713] | 553 | 0, 0, 0 ) ) giet_pthread_exit("ERROR in FBF_CMA_DISPLAY"); |
---|
[258] | 554 | } |
---|
[295] | 555 | |
---|
[722] | 556 | ///////////////////////////////////////////// |
---|
| 557 | void giet_fbf_cma_check( unsigned int index ) |
---|
| 558 | { |
---|
| 559 | if ( sys_call( SYSCALL_FBF_CMA_CHECK, |
---|
| 560 | index, |
---|
| 561 | 0, 0, 0 ) ) giet_pthread_exit("ERROR in FBF_CMA_CHECK"); |
---|
| 562 | } |
---|
| 563 | |
---|
[295] | 564 | //////////////////////// |
---|
[438] | 565 | void giet_fbf_cma_stop() |
---|
[258] | 566 | { |
---|
[438] | 567 | if ( sys_call( SYSCALL_FBF_CMA_STOP, |
---|
[722] | 568 | 0, 0, 0, 0 ) ) giet_pthread_exit("ERROR in FBF_CMA_STOP"); |
---|
[258] | 569 | } |
---|
| 570 | |
---|
[438] | 571 | ////////////////////////////////////////////// |
---|
| 572 | void giet_fbf_sync_write( unsigned int offset, |
---|
| 573 | void * buffer, |
---|
| 574 | unsigned int length ) |
---|
| 575 | { |
---|
| 576 | if ( sys_call( SYSCALL_FBF_SYNC_WRITE, |
---|
| 577 | offset, |
---|
| 578 | (unsigned int)buffer, |
---|
| 579 | length, |
---|
[713] | 580 | 0 ) ) giet_pthread_exit("ERROR in FBF_SYNC_WRITE"); |
---|
[438] | 581 | } |
---|
[258] | 582 | |
---|
[438] | 583 | ///////////////////////////////////////////// |
---|
| 584 | void giet_fbf_sync_read( unsigned int offset, |
---|
| 585 | void * buffer, |
---|
| 586 | unsigned int length ) |
---|
| 587 | { |
---|
| 588 | if ( sys_call( SYSCALL_FBF_SYNC_READ, |
---|
| 589 | offset, |
---|
| 590 | (unsigned int)buffer, |
---|
| 591 | length, |
---|
[713] | 592 | 0 ) ) giet_pthread_exit("ERROR in FBF_SYNC_READ"); |
---|
[438] | 593 | } |
---|
| 594 | |
---|
| 595 | |
---|
[258] | 596 | ////////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 597 | // NIC related system calls |
---|
[258] | 598 | ////////////////////////////////////////////////////////////////////////////////// |
---|
| 599 | |
---|
[709] | 600 | ////////////////////////////////////////// |
---|
| 601 | void giet_nic_rx_alloc( unsigned int xmax, |
---|
| 602 | unsigned int ymax ) |
---|
[258] | 603 | { |
---|
[709] | 604 | if ( sys_call( SYSCALL_NIC_ALLOC, |
---|
| 605 | 1, // RX |
---|
| 606 | xmax, |
---|
| 607 | ymax, |
---|
| 608 | 0 ) ) giet_pthread_exit("error in giet_nic_rx_alloc()"); |
---|
[258] | 609 | } |
---|
[295] | 610 | |
---|
[709] | 611 | ////////////////////////////////////////// |
---|
| 612 | void giet_nic_tx_alloc( unsigned int xmax, |
---|
| 613 | unsigned int ymax ) |
---|
[258] | 614 | { |
---|
[709] | 615 | if ( sys_call( SYSCALL_NIC_ALLOC, |
---|
| 616 | 0, // TX |
---|
| 617 | xmax, |
---|
| 618 | ymax, |
---|
| 619 | 0 ) ) giet_pthread_exit("error in giet_nic_tx_alloc()"); |
---|
[450] | 620 | } |
---|
| 621 | |
---|
[709] | 622 | //////////////////////// |
---|
| 623 | void giet_nic_rx_start() |
---|
[450] | 624 | { |
---|
[461] | 625 | if ( sys_call( SYSCALL_NIC_START, |
---|
[709] | 626 | 1, // RX |
---|
| 627 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_nic_rx_start()"); |
---|
[450] | 628 | } |
---|
| 629 | |
---|
[709] | 630 | //////////////////////// |
---|
| 631 | void giet_nic_tx_start() |
---|
[450] | 632 | { |
---|
[461] | 633 | if ( sys_call( SYSCALL_NIC_START, |
---|
[709] | 634 | 0, // TX |
---|
| 635 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_nic_tx_start()"); |
---|
[450] | 636 | } |
---|
| 637 | |
---|
[709] | 638 | ///////////////////////////////////// |
---|
| 639 | void giet_nic_rx_move( void* buffer ) |
---|
[450] | 640 | { |
---|
[461] | 641 | if ( sys_call( SYSCALL_NIC_MOVE, |
---|
[709] | 642 | 1, // RX |
---|
[438] | 643 | (unsigned int)buffer, |
---|
[709] | 644 | 0, 0 ) ) giet_pthread_exit("error in giet_nic_rx_move()"); |
---|
[258] | 645 | } |
---|
| 646 | |
---|
[709] | 647 | ///////////////////////////////////// |
---|
| 648 | void giet_nic_tx_move( void* buffer ) |
---|
[438] | 649 | { |
---|
[461] | 650 | if ( sys_call( SYSCALL_NIC_MOVE, |
---|
[709] | 651 | 0, // TX |
---|
[438] | 652 | (unsigned int)buffer, |
---|
[709] | 653 | 0, 0 ) ) giet_pthread_exit("error in giet_nic_tx_move()"); |
---|
[438] | 654 | } |
---|
| 655 | |
---|
[709] | 656 | /////////////////////// |
---|
| 657 | void giet_nic_rx_stop() |
---|
[450] | 658 | { |
---|
[461] | 659 | if ( sys_call( SYSCALL_NIC_STOP, |
---|
[709] | 660 | 1, // RX |
---|
| 661 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_nic_rx_stop()"); |
---|
[450] | 662 | } |
---|
| 663 | |
---|
[709] | 664 | /////////////////////// |
---|
| 665 | void giet_nic_tx_stop() |
---|
[450] | 666 | { |
---|
[461] | 667 | if ( sys_call( SYSCALL_NIC_STOP, |
---|
[709] | 668 | 0, // TX |
---|
| 669 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_nic_tx_stop()"); |
---|
[450] | 670 | } |
---|
| 671 | |
---|
[709] | 672 | //////////////////////// |
---|
| 673 | void giet_nic_rx_stats() |
---|
[461] | 674 | { |
---|
| 675 | if ( sys_call( SYSCALL_NIC_STATS, |
---|
[709] | 676 | 1, // RX |
---|
| 677 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_nic_rx_stats()"); |
---|
[461] | 678 | } |
---|
[450] | 679 | |
---|
[709] | 680 | //////////////////////// |
---|
| 681 | void giet_nic_tx_stats() |
---|
[461] | 682 | { |
---|
| 683 | if ( sys_call( SYSCALL_NIC_STATS, |
---|
[709] | 684 | 0, // TX |
---|
| 685 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_nic_tx_stats()"); |
---|
[461] | 686 | } |
---|
| 687 | |
---|
[709] | 688 | //////////////////////// |
---|
| 689 | void giet_nic_rx_clear() |
---|
[461] | 690 | { |
---|
| 691 | if ( sys_call( SYSCALL_NIC_CLEAR, |
---|
[709] | 692 | 1, // RX |
---|
| 693 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_nic_rx_clear()"); |
---|
[461] | 694 | } |
---|
| 695 | |
---|
[709] | 696 | //////////////////////// |
---|
| 697 | void giet_nic_tx_clear() |
---|
[461] | 698 | { |
---|
| 699 | if ( sys_call( SYSCALL_NIC_CLEAR, |
---|
[709] | 700 | 0, // TX |
---|
| 701 | 0, 0, 0 ) ) giet_pthread_exit("error in giet_nic_tx_clear()"); |
---|
[461] | 702 | } |
---|
| 703 | |
---|
| 704 | |
---|
| 705 | |
---|
[295] | 706 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 707 | // FAT related system calls |
---|
[295] | 708 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[258] | 709 | |
---|
[588] | 710 | ///////////////////////////////////////// |
---|
| 711 | int giet_fat_open( char* pathname, |
---|
| 712 | unsigned int flags ) |
---|
[295] | 713 | { |
---|
[588] | 714 | return sys_call( SYSCALL_FAT_OPEN, |
---|
| 715 | (unsigned int)pathname, |
---|
| 716 | flags, |
---|
| 717 | 0, 0 ); |
---|
[295] | 718 | } |
---|
[258] | 719 | |
---|
[588] | 720 | ///////////////////////////////////////// |
---|
| 721 | int giet_fat_close( unsigned int fd_id ) |
---|
[295] | 722 | { |
---|
[588] | 723 | return sys_call( SYSCALL_FAT_CLOSE, |
---|
| 724 | fd_id, |
---|
| 725 | 0, 0, 0 ); |
---|
[295] | 726 | } |
---|
| 727 | |
---|
[588] | 728 | ///////////////////////////////////////////// |
---|
[623] | 729 | int giet_fat_file_info( unsigned int fd_id, |
---|
| 730 | struct fat_file_info_s* info ) |
---|
[295] | 731 | { |
---|
[588] | 732 | return sys_call( SYSCALL_FAT_FINFO, |
---|
| 733 | fd_id, |
---|
[623] | 734 | (unsigned int)info, |
---|
| 735 | 0, 0 ); |
---|
[295] | 736 | } |
---|
| 737 | |
---|
[588] | 738 | /////////////////////////////////////// |
---|
| 739 | int giet_fat_read( unsigned int fd_id, |
---|
| 740 | void* buffer, |
---|
| 741 | unsigned int count ) |
---|
| 742 | { |
---|
| 743 | return sys_call( SYSCALL_FAT_READ, |
---|
| 744 | fd_id, |
---|
| 745 | (unsigned int)buffer, |
---|
| 746 | count, |
---|
[759] | 747 | 0 ); |
---|
[588] | 748 | } |
---|
| 749 | |
---|
[759] | 750 | /////////////////////////////////////// |
---|
| 751 | int giet_fat_pread( unsigned int fd_id, |
---|
| 752 | void* buffer, |
---|
| 753 | unsigned int count, |
---|
| 754 | unsigned int offset ) |
---|
| 755 | { |
---|
| 756 | return sys_call( SYSCALL_FAT_PREAD, |
---|
| 757 | fd_id, |
---|
| 758 | (unsigned int)buffer, |
---|
| 759 | count, |
---|
| 760 | offset ); |
---|
| 761 | } |
---|
| 762 | |
---|
[588] | 763 | //////////////////////////////////////// |
---|
| 764 | int giet_fat_write( unsigned int fd_id, |
---|
[295] | 765 | void* buffer, |
---|
[588] | 766 | unsigned int count ) |
---|
[258] | 767 | { |
---|
[295] | 768 | return sys_call( SYSCALL_FAT_WRITE, |
---|
[588] | 769 | fd_id, |
---|
[295] | 770 | (unsigned int)buffer, |
---|
[588] | 771 | count, |
---|
[759] | 772 | 0 ); |
---|
[258] | 773 | } |
---|
[295] | 774 | |
---|
[588] | 775 | //////////////////////////////////////// |
---|
| 776 | int giet_fat_lseek( unsigned int fd_id, |
---|
[295] | 777 | unsigned int offset, |
---|
| 778 | unsigned int whence ) |
---|
[258] | 779 | { |
---|
[588] | 780 | return sys_call( SYSCALL_FAT_LSEEK, |
---|
| 781 | fd_id, |
---|
| 782 | offset, |
---|
| 783 | whence, |
---|
| 784 | 0 ); |
---|
[258] | 785 | } |
---|
[295] | 786 | |
---|
[588] | 787 | //////////////////////////////////////////// |
---|
| 788 | int giet_fat_remove( char* pathname, |
---|
| 789 | unsigned int should_be_dir ) |
---|
[258] | 790 | { |
---|
[588] | 791 | return sys_call( SYSCALL_FAT_REMOVE, |
---|
| 792 | (unsigned int)pathname, |
---|
| 793 | should_be_dir, |
---|
| 794 | 0, 0 ); |
---|
[258] | 795 | } |
---|
[295] | 796 | |
---|
| 797 | ///////////////////////////////////// |
---|
[588] | 798 | int giet_fat_rename( char* old_path, |
---|
| 799 | char* new_path ) |
---|
[258] | 800 | { |
---|
[588] | 801 | return sys_call( SYSCALL_FAT_RENAME, |
---|
| 802 | (unsigned int)old_path, |
---|
| 803 | (unsigned int)new_path, |
---|
| 804 | 0, 0 ); |
---|
[258] | 805 | } |
---|
[295] | 806 | |
---|
[588] | 807 | //////////////////////////////////// |
---|
| 808 | int giet_fat_mkdir( char* pathname ) |
---|
| 809 | { |
---|
| 810 | return sys_call( SYSCALL_FAT_MKDIR, |
---|
| 811 | (unsigned int)pathname, |
---|
| 812 | 0, 0, 0 ); |
---|
| 813 | } |
---|
[295] | 814 | |
---|
[659] | 815 | //////////////////////////////////// |
---|
| 816 | int giet_fat_opendir( char* pathname ) |
---|
| 817 | { |
---|
| 818 | return sys_call( SYSCALL_FAT_OPENDIR, |
---|
| 819 | (unsigned int)pathname, |
---|
| 820 | 0, 0, 0 ); |
---|
| 821 | } |
---|
| 822 | |
---|
| 823 | //////////////////////////////////// |
---|
| 824 | int giet_fat_closedir( unsigned int fd_id ) |
---|
| 825 | { |
---|
| 826 | return sys_call( SYSCALL_FAT_CLOSEDIR, |
---|
| 827 | (unsigned int)fd_id, |
---|
| 828 | 0, 0, 0 ); |
---|
| 829 | } |
---|
| 830 | |
---|
[743] | 831 | ////////////////////////////////////////// |
---|
[659] | 832 | int giet_fat_readdir( unsigned int fd_id, |
---|
| 833 | fat_dirent_t* entry ) |
---|
| 834 | { |
---|
| 835 | return sys_call( SYSCALL_FAT_READDIR, |
---|
| 836 | (unsigned int)fd_id, |
---|
| 837 | (unsigned int)entry, |
---|
| 838 | 0, 0 ); |
---|
| 839 | } |
---|
| 840 | |
---|
[743] | 841 | ///////////////////////////////////////// |
---|
| 842 | int giet_fat_fprintf( unsigned int fd_id, |
---|
| 843 | char* format, |
---|
[749] | 844 | ... ) |
---|
[743] | 845 | { |
---|
| 846 | va_list args; |
---|
[771] | 847 | char string[4096]; |
---|
[749] | 848 | unsigned int count; |
---|
[295] | 849 | |
---|
[743] | 850 | va_start( args, format ); |
---|
[771] | 851 | count = xprintf( string , 4096 , format , &args ); |
---|
[743] | 852 | va_end( args ); |
---|
[295] | 853 | |
---|
[759] | 854 | if ( count == 0xFFFFFFFF ) giet_pthread_exit("error in giet_fat_fprintf()"); |
---|
[743] | 855 | |
---|
| 856 | return sys_call( SYSCALL_FAT_WRITE, |
---|
| 857 | fd_id, |
---|
[771] | 858 | (unsigned int)string, |
---|
[743] | 859 | count, |
---|
| 860 | 0 ); // no physical addressing required |
---|
| 861 | } |
---|
| 862 | |
---|
[759] | 863 | ///////////////////////////////////////// |
---|
| 864 | void* giet_fat_mmap( void* vaddr, // MAP_FIXED not supported |
---|
| 865 | unsigned int length, |
---|
| 866 | unsigned int prot, |
---|
| 867 | unsigned int flags, |
---|
| 868 | unsigned int fd_id, |
---|
| 869 | unsigned int offset ) |
---|
| 870 | { |
---|
| 871 | if ( flags & MAP_FIXED ) giet_pthread_exit("error in giet_fat_mmap()"); |
---|
| 872 | if ( flags & MAP_PRIVATE ) giet_pthread_exit("error in giet_fat_mmap()"); |
---|
| 873 | if ( flags & MAP_ANONYMOUS ) giet_pthread_exit("error in giet_fat_mmap()"); |
---|
| 874 | if ( length & 0xFFF ) giet_pthread_exit("error in giet_fat_mmap()"); |
---|
| 875 | if ( offset & 0xFFF ) giet_pthread_exit("error in giet_fat_mmap()"); |
---|
[743] | 876 | |
---|
[759] | 877 | return (void*)sys_call( SYSCALL_FAT_MMAP, |
---|
| 878 | fd_id, |
---|
| 879 | length>>12, |
---|
| 880 | offset>>12, |
---|
| 881 | prot ); |
---|
| 882 | } |
---|
| 883 | |
---|
[765] | 884 | /////////////////////////////////////////// |
---|
| 885 | int giet_fat_munmap( void* vaddr, |
---|
| 886 | unsigned int length ) |
---|
| 887 | { |
---|
[767] | 888 | if ( length & 0xFFF ) giet_pthread_exit("error in giet_fat_munmap()"); |
---|
| 889 | if ( (unsigned int)vaddr & 0xFFF ) giet_pthread_exit("error in giet_fat_munmap()"); |
---|
[759] | 890 | |
---|
[767] | 891 | return sys_call( SYSCALL_FAT_MUNMAP, |
---|
[765] | 892 | (unsigned int)vaddr, |
---|
| 893 | length>>12, |
---|
| 894 | 0, 0 ); |
---|
| 895 | } |
---|
| 896 | |
---|
[771] | 897 | /////////////////////////////////////// |
---|
| 898 | int giet_fat_dump( unsigned int type, |
---|
| 899 | char* pathname, |
---|
| 900 | unsigned int block_id ) |
---|
| 901 | { |
---|
| 902 | return sys_call( SYSCALL_FAT_DUMP, |
---|
| 903 | type, |
---|
| 904 | (unsigned int)pathname, |
---|
| 905 | block_id, |
---|
| 906 | 0 ); |
---|
| 907 | |
---|
| 908 | } |
---|
| 909 | |
---|
| 910 | |
---|
[390] | 911 | ////////////////////////////////////////////////////////////////////////////////// |
---|
[709] | 912 | // Miscellaneous system calls |
---|
[390] | 913 | ////////////////////////////////////////////////////////////////////////////////// |
---|
| 914 | |
---|
[501] | 915 | ///////////////////////////////////////////////// |
---|
| 916 | void giet_procs_number( unsigned int* x_size, |
---|
| 917 | unsigned int* y_size, |
---|
| 918 | unsigned int* nprocs ) |
---|
[438] | 919 | { |
---|
[501] | 920 | if ( sys_call( SYSCALL_PROCS_NUMBER, |
---|
| 921 | (unsigned int)x_size, |
---|
| 922 | (unsigned int)y_size, |
---|
| 923 | (unsigned int)nprocs, |
---|
[709] | 924 | 0 ) ) giet_pthread_exit("error in giet_procs_number()"); |
---|
[438] | 925 | } |
---|
| 926 | |
---|
[295] | 927 | //////////////////////////////////////////////////// |
---|
| 928 | void giet_vobj_get_vbase( char* vspace_name, |
---|
| 929 | char* vobj_name, |
---|
[438] | 930 | unsigned int* vbase ) |
---|
[258] | 931 | { |
---|
[295] | 932 | if ( sys_call( SYSCALL_VOBJ_GET_VBASE, |
---|
| 933 | (unsigned int) vspace_name, |
---|
| 934 | (unsigned int) vobj_name, |
---|
[438] | 935 | (unsigned int) vbase, |
---|
[709] | 936 | 0 ) ) giet_pthread_exit("error in giet_vobj_get_vbase()"); |
---|
[258] | 937 | } |
---|
[260] | 938 | |
---|
[438] | 939 | //////////////////////////////////////////////////// |
---|
| 940 | void giet_vobj_get_length( char* vspace_name, |
---|
| 941 | char* vobj_name, |
---|
| 942 | unsigned int* length ) |
---|
[260] | 943 | { |
---|
[438] | 944 | if ( sys_call( SYSCALL_VOBJ_GET_LENGTH, |
---|
| 945 | (unsigned int) vspace_name, |
---|
| 946 | (unsigned int) vobj_name, |
---|
| 947 | (unsigned int) length, |
---|
[709] | 948 | 0 ) ) giet_pthread_exit("error in giet_vobj_get_length()"); |
---|
[260] | 949 | } |
---|
| 950 | |
---|
[295] | 951 | ///////////////////////////////////////// |
---|
| 952 | void giet_heap_info( unsigned int* vaddr, |
---|
[368] | 953 | unsigned int* length, |
---|
| 954 | unsigned int x, |
---|
| 955 | unsigned int y ) |
---|
[258] | 956 | { |
---|
[709] | 957 | sys_call( SYSCALL_HEAP_INFO, |
---|
| 958 | (unsigned int)vaddr, |
---|
| 959 | (unsigned int)length, |
---|
| 960 | x, |
---|
| 961 | y ); |
---|
[258] | 962 | } |
---|
| 963 | |
---|
[390] | 964 | ///////////////////////////////////////// |
---|
| 965 | void giet_get_xy( void* ptr, |
---|
| 966 | unsigned int* px, |
---|
| 967 | unsigned int* py ) |
---|
| 968 | { |
---|
| 969 | if ( sys_call( SYSCALL_GET_XY, |
---|
| 970 | (unsigned int)ptr, |
---|
| 971 | (unsigned int)px, |
---|
| 972 | (unsigned int)py, |
---|
[709] | 973 | 0 ) ) giet_pthread_exit("error in giet_get_xy()"); |
---|
[390] | 974 | } |
---|
| 975 | |
---|
[258] | 976 | // Local Variables: |
---|
| 977 | // tab-width: 4 |
---|
| 978 | // c-basic-offset: 4 |
---|
| 979 | // c-file-offsets:((innamespace . 0)(inline-open . 0)) |
---|
| 980 | // indent-tabs-mode: nil |
---|
| 981 | // End: |
---|
| 982 | // vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 |
---|
| 983 | |
---|