URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [hal/] [synth/] [arch/] [current/] [include/] [hal_io.h] - Rev 786
Compare with Previous | Blame | View Log
#ifndef CYGONCE_HAL_HAL_IO_H #define CYGONCE_HAL_HAL_IO_H //============================================================================= // // hal_io.h // // HAL device IO register support. // //============================================================================= // ####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. // // eCos is free software; you can redistribute it and/or modify it under // the terms of the GNU General Public License as published by the Free // Software Foundation; either version 2 or (at your option) any later // version. // // eCos is distributed in the hope that it will be useful, but WITHOUT // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License // for more details. // // You should have received a copy of the GNU General Public License // along with eCos; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // // As a special exception, if other files instantiate templates or use // macros or inline functions from this file, or you compile this file // and link it with other works to produce a work based on this file, // this file does not by itself cause the resulting work to be covered by // the GNU General Public License. However the source code for this file // must still be made available in accordance with section (3) of the GNU // General Public License v2. // // This exception does not invalidate any other reasons why a work based // on this file might be covered by the GNU General Public License. // ------------------------------------------- // ####ECOSGPLCOPYRIGHTEND#### //============================================================================= //#####DESCRIPTIONBEGIN#### // // Author(s): nickg // Contributors:nickg, bartv, alunn, jlarmour // Date: 1998-02-17 // Purpose: Define IO register support // Description: The macros defined here provide the HAL APIs for handling // device IO control registers. // // For the synthetic target these macros should never // actually be used since the application will run as an // ordinary user application and should not have // permission to access any real hardware. Instead // hardware access should go via the auxiliary. Possibly // the macros should be #pragma poison'd, but some people // may want to run the synthetic target in a way that // does involve accessing real hardware. // // The synthetic target provides some additional I/O // facilities in the form of Linux system calls. A useful // subset of these are prototyped here, together with // associated constants. There are also I/O operations to // interact with the auxiliary. // // Usage: // #include <cyg/hal/hal_io.h> // ... // //####DESCRIPTIONEND#### // //============================================================================= #include <cyg/infra/cyg_type.h> #include <cyg/hal/var_io.h> // Variant-specific definitions //----------------------------------------------------------------------------- // IO Register address. // This type is for recording the address of an IO register. typedef volatile CYG_ADDRWORD HAL_IO_REGISTER; //----------------------------------------------------------------------------- // BYTE Register access. // Individual and vectorized access to 8 bit registers. #define HAL_READ_UINT8( _register_, _value_ ) \ CYG_MACRO_START \ ((_value_) = *((volatile CYG_BYTE *)(_register_))); \ CYG_MACRO_END #define HAL_WRITE_UINT8( _register_, _value_ ) \ CYG_MACRO_START \ (*((volatile CYG_BYTE *)(_register_)) = (_value_)); \ CYG_MACRO_END #define HAL_READ_UINT8_VECTOR( _register_, _buf_, _count_, _step_ ) \ CYG_MACRO_START \ cyg_count32 _i_,_j_; \ for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) { \ (_buf_)[_i_] = ((volatile CYG_BYTE *)(_register_))[_j_]; \ } \ CYG_MACRO_END #define HAL_WRITE_UINT8_VECTOR( _register_, _buf_, _count_, _step_ ) \ CYG_MACRO_START \ cyg_count32 _i_,_j_; \ for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) { \ ((volatile CYG_BYTE *)(_register_))[_j_] = (_buf_)[_i_]; \ } \ CYG_MACRO_END //----------------------------------------------------------------------------- // 16 bit access. // Individual and vectorized access to 16 bit registers. #define HAL_READ_UINT16( _register_, _value_ ) \ CYG_MACRO_START \ ((_value_) = *((volatile CYG_WORD16 *)(_register_))); \ CYG_MACRO_END #define HAL_WRITE_UINT16( _register_, _value_ ) \ CYG_MACRO_START \ (*((volatile CYG_WORD16 *)(_register_)) = (_value_)); \ CYG_MACRO_END #define HAL_READ_UINT16_VECTOR( _register_, _buf_, _count_, _step_ ) \ CYG_MACRO_START \ cyg_count32 _i_,_j_; \ for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) { \ (_buf_)[_i_] = ((volatile CYG_WORD16 *)(_register_))[_j_]; \ } \ CYG_MACRO_END #define HAL_WRITE_UINT16_VECTOR( _register_, _buf_, _count_, _step_ ) \ CYG_MACRO_START \ cyg_count32 _i_,_j_; \ for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) { \ ((volatile CYG_WORD16 *)(_register_))[_j_] = (_buf_)[_i_]; \ } \ CYG_MACRO_END //----------------------------------------------------------------------------- // 32 bit access. // Individual and vectorized access to 32 bit registers. #define HAL_READ_UINT32( _register_, _value_ ) \ CYG_MACRO_START \ ((_value_) = *((volatile CYG_WORD32 *)(_register_))); \ CYG_MACRO_END #define HAL_WRITE_UINT32( _register_, _value_ ) \ CYG_MACRO_START \ (*((volatile CYG_WORD32 *)(_register_)) = (_value_)); \ CYG_MACRO_END #define HAL_READ_UINT32_VECTOR( _register_, _buf_, _count_, _step_ ) \ CYG_MACRO_START \ cyg_count32 _i_,_j_; \ for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) { \ (_buf_)[_i_] = ((volatile CYG_WORD32 *)(_register_))[_j_]; \ } \ CYG_MACRO_END #define HAL_WRITE_UINT32_VECTOR( _register_, _buf_, _count_, _step_ ) \ CYG_MACRO_START \ cyg_count32 _i_,_j_; \ for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) { \ ((volatile CYG_WORD32 *)(_register_))[_j_] = (_buf_)[_i_]; \ } \ CYG_MACRO_END // ---------------------------------------------------------------------------- // Linux system calls and associated structures and constants. This is // by no means a complete list, but there is enough information for // the needs of the relevant HAL packages. The information needs to be // kept in synch with the Linux header files, but in practice // divergence will be rare because that would imply incompatible // changes in the Linux kernel API. // // It may seem tempting to import the Linux header files directly, but // that would prevent cross-compilation and introduce all kinds of // namespace pollution. // // The actual implementation lives in variant HAL packages since // typically they involve direct system calls via bits of assembler. // Note that only a subset of system calls are actually implemented, // so the variant HALs may need to be updated if this list needs to // be extended. // Error codes. #define CYG_HAL_SYS_EINTR 4 #define CYG_HAL_SYS_EAGAIN 11 // Signal-related information #define CYG_HAL_SYS_SIGHUP 1 #define CYG_HAL_SYS_SIGINT 2 #define CYG_HAL_SYS_SIGQUIT 3 #define CYG_HAL_SYS_SIGILL 4 #define CYG_HAL_SYS_SIGTRAP 5 #define CYG_HAL_SYS_SIGABRT 6 #define CYG_HAL_SYS_SIGBUS 7 #define CYG_HAL_SYS_SIGFPE 8 #define CYG_HAL_SYS_SIGKILL 9 #define CYG_HAL_SYS_SIGUSR1 10 #define CYG_HAL_SYS_SIGSEGV 11 #define CYG_HAL_SYS_SIGUSR2 12 #define CYG_HAL_SYS_SIGPIPE 13 #define CYG_HAL_SYS_SIGALRM 14 #define CYG_HAL_SYS_SIGTERM 15 #define CYG_HAL_SYS_SIGSTKFLT 16 #define CYG_HAL_SYS_SIGCHLD 17 #define CYG_HAL_SYS_SIGCONT 18 #define CYG_HAL_SYS_SIGSTOP 19 #define CYG_HAL_SYS_SIGTSTP 20 #define CYG_HAL_SYS_SIGTTIN 21 #define CYG_HAL_SYS_SIGTTOU 22 #define CYG_HAL_SYS_SIGURG 23 #define CYG_HAL_SYS_SIGXCPU 24 #define CYG_HAL_SYS_SIGXFSZ 25 #define CYG_HAL_SYS_SIGVTALRM 26 #define CYG_HAL_SYS_SIGPROF 27 #define CYG_HAL_SYS_SIGWINCH 28 #define CYG_HAL_SYS_SIGIO 29 #define CYG_HAL_SYS_SIGPWR 30 #define CYG_HAL_SYS_SIGSYS 31 #define CYG_HAL_SYS_SA_NOCLDSTOP 0x00000001 #define CYG_HAL_SYS_SA_NOCLDWAIT 0x00000002 #define CYG_HAL_SYS_SA_SIGINFO 0x00000004 #define CYG_HAL_SYS_SA_RESTORER 0x04000000 #define CYG_HAL_SYS_SA_RESTART 0x10000000 #define CYG_HAL_SYS_SA_NODEFER 0x40000000 #define CYG_HAL_SYS_SIG_BLOCK 0 #define CYG_HAL_SYS_SIG_UNBLOCK 1 #define CYG_HAL_SYS_SIG_SETMASK 2 #define CYG_HAL_SYS__NSIG 64 #define CYG_HAL_SYS__SIGBITS (8 * sizeof(unsigned long)) #define CYG_HAL_SYS__SIGELT(_d_) ((_d_) / CYG_HAL_SYS__SIGBITS) #define CYG_HAL_SYS__SIGMASK(_d_) ((unsigned long)1 << ((_d_) % CYG_HAL_SYS__SIGBITS)) typedef struct cyg_hal_sys_sigset_t { unsigned long hal_sig_bits[CYG_HAL_SYS__NSIG / CYG_HAL_SYS__SIGBITS]; } cyg_hal_sys_sigset_t; #define CYG_HAL_SYS_SIGFILLSET(_set_) \ CYG_MACRO_START \ unsigned int __i; \ for (__i = 0; __i < (CYG_HAL_SYS__NSIG / CYG_HAL_SYS__SIGBITS); __i++) { \ (_set_)->hal_sig_bits[__i] = ~0; \ } \ CYG_MACRO_END #define CYG_HAL_SYS_SIGEMPTYSET(_set_) \ CYG_MACRO_START \ unsigned int __i; \ for (__i = 0; __i < (CYG_HAL_SYS__NSIG / CYG_HAL_SYS__SIGBITS); __i++) { \ (_set_)->hal_sig_bits[__i] = 0; \ } \ CYG_MACRO_END #define CYG_HAL_SYS_SIGADDSET(_set_, _bit_) \ CYG_MACRO_START \ (_set_)->hal_sig_bits[CYG_HAL_SYS__SIGELT(_bit_ - 1)] |= CYG_HAL_SYS__SIGMASK(_bit_ - 1); \ CYG_MACRO_END #define CYG_HAL_SYS_SIGDELSET(_set_, _bit_) \ CYG_MACRO_START \ (_set_)->hal_sig_bits[CYG_HAL_SYS__SIGELT(_bit_ - 1)] &= ~CYG_HAL_SYS__SIGMASK(_bit_ - 1); \ CYG_MACRO_END #define CYG_HAL_SYS_SIGISMEMBER(_set_, _bit_) \ (0 != ((_set_)->hal_sig_bits[CYG_HAL_SYS__SIGELT(_bit_ - 1)] & CYG_HAL_SYS__SIGMASK(_bit_ - 1))) // The kernel sigaction structure has changed, to allow for >32 // signals. This is the old version, i.e. a struct old_sigaction, for // use with the sigaction() system call rather than rt_sigaction(). It // is preferred to the more modern version because gdb knows about // rt_sigaction() and will start intercepting signals, but it seems to // ignore sigaction(). struct cyg_hal_sys_sigaction { void (*hal_handler)(int); long hal_mask; int hal_flags; void (*hal_restorer)(void); }; // Time support. struct cyg_hal_sys_timeval { long hal_tv_sec; long hal_tv_usec; }; struct cyg_hal_sys_timezone { int hal_tz_minuteswest; int hal_tz_dsttime; }; // Select support. Initially this is used only by the idle handler. #define CYG_HAL_SYS_FD_SETSIZE 1024 #define CYG_HAL_SYS__NFDBITS (8 * sizeof(unsigned long)) #define CYG_HAL_SYS__FDELT(_d_) ((_d_) / CYG_HAL_SYS__NFDBITS) #define CYG_HAL_SYS__FDMASK(_d_) ((unsigned long)1 << ((_d_) % CYG_HAL_SYS__NFDBITS)) struct cyg_hal_sys_fd_set { unsigned long hal_fds_bits[CYG_HAL_SYS_FD_SETSIZE / CYG_HAL_SYS__NFDBITS]; }; #define CYG_HAL_SYS_FD_ZERO(_fdsp_) \ do { \ unsigned int __i; \ for (__i = 0; \ __i < (CYG_HAL_SYS_FD_SETSIZE / CYG_HAL_SYS__NFDBITS); \ __i++) { \ (_fdsp_)->hal_fds_bits[__i] = 0; \ } \ } while (0); #define CYG_HAL_SYS_FD_SET(_fd_, _fdsp_) \ CYG_MACRO_START \ (_fdsp_)->hal_fds_bits[CYG_HAL_SYS__FDELT(_fd_)] |= CYG_HAL_SYS__FDMASK(_fd_); \ CYG_MACRO_END #define CYG_HAL_SYS_FD_CLR(_fd_, _fdsp_) \ CYG_MACRO_START \ (_fdsp_)->hal_fds_bits[CYG_HAL_SYS__FDELT(_fd_)] &= ~CYG_HAL_SYS__FDMASK(_fd_); \ CYG_MACRO_END #define CYG_HAL_SYS_FD_ISSET(_fd_, _fdsp_) \ (0 != ((_fdsp_)->hal_fds_bits[CYG_HAL_SYS__FDELT(_fd_)] & CYG_HAL_SYS__FDMASK(_fd_))) // Interval timer support, needed for the clock. #define CYG_HAL_SYS_ITIMER_REAL 0 #define CYG_HAL_SYS_ITIMER_VIRTUAL 1 #define CYG_HAL_SYS_ITIMER_PROF 2 struct cyg_hal_sys_itimerval { struct cyg_hal_sys_timeval hal_it_interval; struct cyg_hal_sys_timeval hal_it_value; }; // System calls and related constants, or rather the subset that is // needed internally. #define CYG_HAL_SYS_R_OK 0x04 #define CYG_HAL_SYS_W_OK 0x02 #define CYG_HAL_SYS_X_OK 0x01 #define CYG_HAL_SYS_F_OK 0x00 /* lseek whence flags */ #define CYG_HAL_SYS_SEEK_SET 0 /* Seek from beginning of file. */ #define CYG_HAL_SYS_SEEK_CUR 1 /* Seek from current position. */ #define CYG_HAL_SYS_SEEK_END 2 /* Seek from end of file. */ /* open/fcntl flags */ #define CYG_HAL_SYS_O_RDONLY 0 #define CYG_HAL_SYS_O_WRONLY 01 #define CYG_HAL_SYS_O_RDWR 02 #define CYG_HAL_SYS_O_CREAT 0100 #define CYG_HAL_SYS_O_EXCL 0200 #define CYG_HAL_SYS_O_NOCTTY 0400 #define CYG_HAL_SYS_O_TRUNC 01000 #define CYG_HAL_SYS_O_APPEND 02000 #define CYG_HAL_SYS_O_NONBLOCK 04000 #define CYG_HAL_SYS_O_NDELAY CYG_HAL_SYS_O_NONBLOCK #define CYG_HAL_SYS_O_SYNC 010000 #define CYG_HAL_SYS_O_FSYNC CYG_HAL_SYS_O_SYNC #define CYG_HAL_SYS_O_ASYNC 020000 /* open mode flags */ #define CYG_HAL_SYS_S_IRUSR 0400 #define CYG_HAL_SYS_S_IREAD CYG_HAL_SYS_S_IRUSR #define CYG_HAL_SYS_S_IWUSR 0200 #define CYG_HAL_SYS_S_IWRITE CYG_HAL_SYS_S_IWUSR #define CYG_HAL_SYS_S_IXUSR 0100 #define CYG_HAL_SYS_S_IEXEC CYG_HAL_SYS_S_IXUSR #define CYG_HAL_SYS_S_IRWXU \ (CYG_HAL_SYS_S_IREAD|CYG_HAL_SYS_S_IWRITE|CYG_HAL_SYS_S_IEXEC) #define CYG_HAL_SYS_S_IRWXG (CYG_HAL_SYS_S_IRWXU>>3) #define CYG_HAL_SYS_S_IRGRP (CYG_HAL_SYS_S_IRUSR>>3) #define CYG_HAL_SYS_S_IWGRP (CYG_HAL_SYS_S_IWUSR>>3) #define CYG_HAL_SYS_S_IXGRP (CYG_HAL_SYS_S_IXUSR>>3) #define CYG_HAL_SYS_S_IRWXO (CYG_HAL_SYS_S_IRWXG>>3) #define CYG_HAL_SYS_S_IROTH (CYG_HAL_SYS_S_IRGRP>>3) #define CYG_HAL_SYS_S_IWOTH (CYG_HAL_SYS_S_IWGRP>>3) #define CYG_HAL_SYS_S_IXOTH (CYG_HAL_SYS_S_IXGRP>>3) /* stat flags */ #define CYG_HAL_SYS_S_IFMT 0170000 /*bitmask for the file type bitfields*/ #define CYG_HAL_SYS_S_IFSOCK 0140000 /*socket*/ #define CYG_HAL_SYS_S_IFLNK 0120000 /*symbolic link*/ #define CYG_HAL_SYS_S_IFREG 0100000 /*regular file*/ #define CYG_HAL_SYS_S_IFBLK 0060000 /*block device*/ #define CYG_HAL_SYS_S_IFDIR 0040000 /*directory*/ #define CYG_HAL_SYS_S_IFCHR 0020000 /*character device*/ #define CYG_HAL_SYS_S_IFIFO 0010000 /*fifo*/ #define CYG_HAL_SYS_S_ISUID 0004000 /*set UID bit*/ #define CYG_HAL_SYS_S_ISGID 0002000 /*set GID bit (see below)*/ #define CYG_HAL_SYS_S_ISVTX 0001000 /*sticky bit (see below)*/ struct cyg_hal_sys_mmap_args { unsigned long addr; unsigned long len; unsigned long prot; unsigned long flags; unsigned long fd; unsigned long offset; }; /* Protection flags for mmap */ #define CYG_HAL_SYS_PROT_READ 0x1 /* page can be read */ #define CYG_HAL_SYS_PROT_WRITE 0x2 /* page can be written */ #define CYG_HAL_SYS_PROT_EXEC 0x4 /* page can be executed */ #define CYG_HAL_SYS_PROT_NONE 0x0 /* page can not be accessed */ /* Sharing types and other flags */ #define CYG_HAL_SYS_MAP_SHARED 0x01 /* Share changes. */ #define CYG_HAL_SYS_MAP_PRIVATE 0x02 /* Changes are private. */ #define CYG_HAL_SYS_MAP_FIXED 0x10 /* Interpret addr exactly. */ struct cyg_hal_sys_dirent { unsigned long d_ino; unsigned long d_off; unsigned short int d_reclen; char d_name[256]; }; struct cyg_hal_sys_timespec { unsigned int tv_sec; unsigned int tv_nsec; }; // NOTE: This corresponds to __old_kernel_stat in the kernel sources // and should be used with cyg_hal_sys_oldstat etc. struct cyg_hal_sys_old_stat { unsigned short st_dev; /* device */ unsigned short st_ino; /* inode */ unsigned short st_mode; /* protection */ unsigned short st_nlink; /* number of hard links */ unsigned short st_uid; /* user ID of owner */ unsigned short st_gid; /* group ID of owner */ unsigned short st_rdev; /* device type (if inode device) */ unsigned long st_size; /* total size, in bytes */ unsigned long st_atime; /* time of last access */ unsigned long st_mtime; /* time of last modification */ unsigned long st_ctime; /* time of last change */ }; struct cyg_hal_sys_new_stat { unsigned long st_dev; unsigned long st_ino; unsigned short st_mode; unsigned short st_nlink; unsigned short st_uid; unsigned short st_gid; unsigned long st_rdev; unsigned long st_size; unsigned long st_blksize; unsigned long st_blocks; unsigned long st_atime; unsigned long st_atime_nsec; unsigned long st_mtime; unsigned long st_mtime_nsec; unsigned long st_ctime; unsigned long st_ctime_nsec; unsigned long __unused4; unsigned long __unused5; }; // System calls, or rather the subset that is needed internally or by // applications which want to access the host OS. externC unsigned long cyg_hal_sys_write(int, const void*, long); externC unsigned long cyg_hal_sys_read(int, void*, long); externC int cyg_hal_sys_lseek(int, int, int); externC int cyg_hal_sys_open(const char *,int,int); externC int cyg_hal_sys_fdatasync(int); externC int cyg_hal_sys_sigaction(int, const struct cyg_hal_sys_sigaction*, struct cyg_hal_sys_sigaction*); externC int cyg_hal_sys_sigprocmask(int, const cyg_hal_sys_sigset_t*, cyg_hal_sys_sigset_t*); externC int cyg_hal_sys__newselect(int, struct cyg_hal_sys_fd_set*, struct cyg_hal_sys_fd_set*, struct cyg_hal_sys_fd_set*, struct cyg_hal_sys_timeval*); externC int cyg_hal_sys_setitimer(int, const struct cyg_hal_sys_itimerval*, struct cyg_hal_sys_itimerval*); externC int cyg_hal_sys_gettimeofday(struct cyg_hal_sys_timeval*, struct cyg_hal_sys_timezone*); externC int cyg_hal_sys_access(const char*, int); externC int cyg_hal_sys_fork(void); externC int cyg_hal_sys_execve(const char*, const char* [], const char* []); externC int cyg_hal_sys_pipe(int []); externC int cyg_hal_sys_close(int); externC int cyg_hal_sys_dup2(int, int); externC int cyg_hal_sys_unlink(const char*); externC int cyg_hal_sys_rename(const char*, const char*); #define CYG_HAL_SYS_IPCOP_semop 1 #define CYG_HAL_SYS_IPCOP_semget 2 #define CYG_HAL_SYS_IPCOP_semctl 3 #define CYG_HAL_SYS_IPCOP_msgsnd 11 #define CYG_HAL_SYS_IPCOP_msgrcv 12 #define CYG_HAL_SYS_IPCOP_msgget 13 #define CYG_HAL_SYS_IPCOP_msgctl 14 #define CYG_HAL_SYS_IPCOP_shmat 21 #define CYG_HAL_SYS_IPCOP_shmdt 22 #define CYG_HAL_SYS_IPCOP_shmget 23 #define CYG_HAL_SYS_IPCOP_shmctl 24 /*The ipc system call, which is used by the following shmem functions. These may be unportable*/ // Generic system call. Depending on the value of call, it will // perform the following functions. externC int cyg_hal_sys_ipc(int call, int first, int second, int third, void* ptr); //get an identifier for a shared memory segment externC int cyg_hal_sys_shmget (int key, int size, int shmflg); //attach to an shared memory segment externC void * cyg_hal_sys_shmat (int shmid, const void* shmaddr, int shmflg); //detach from it again externC int cyg_hal_sys_shmdt (const void* shmaddr); // Convert a pathname and an identifier into a System V IPC key externC int cyg_hal_sys_ftok(const char* path, int id); // The actual implementation appears to return the new brk() value. externC void* cyg_hal_sys_brk(void*); // Returns the number of characters placed in the buffer or <0 for error, // not a char*. externC int cyg_hal_sys_getcwd(char*, int); // mmap on the "host" system - this may be unportable. This is the // really system call into the kernel which passes one structure // containing all the arguments. externC int cyg_hal_sys_mmapx(struct cyg_hal_sys_mmap_args *); // This is the mmap call that users are used to. externC int cyg_hal_sys_mmap(void *addr, unsigned long length, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long off); externC int cyg_hal_sys_readdir(unsigned int fd, struct cyg_hal_sys_dirent *dp, unsigned int count); // Old syscall versions externC int cyg_hal_sys_oldlstat(const char* name, struct cyg_hal_sys_old_stat *buf); externC int cyg_hal_sys_oldfstat(int fd, struct cyg_hal_sys_old_stat *buf); externC int cyg_hal_sys_oldstat(const char* name, struct cyg_hal_sys_old_stat *buf); // New syscall versions externC int cyg_hal_sys_newlstat(const char* name, struct cyg_hal_sys_new_stat *buf); externC int cyg_hal_sys_newfstat(int fd, struct cyg_hal_sys_new_stat *buf); externC int cyg_hal_sys_newstat(const char* name, struct cyg_hal_sys_old_stat *buf); externC int cyg_hal_sys_mkdir(const char* path, int mode); // Access to environmental data extern int cyg_hal_sys_argc; extern const char** cyg_hal_sys_argv; extern const char** cyg_hal_sys_environ; // ---------------------------------------------------------------------------- // Interaction between the application and the auxiliary. // Is the auxiliary actually in use/available? This flag should be tested by // device drivers prior to attempting any communication with the auxiliary. extern cyg_bool synth_auxiliary_running; // The fundamental I/O operation: sending a request to the auxiliary and // optionally getting back a reply. A null pointer for the response field // indicates that no reply is expected. externC void synth_auxiliary_xchgmsg(int /* devid */, int /* request */, int /* arg1 */, int /* arg2 */, const unsigned char* /* txdata */, int /* txlen */, int* /* response */, unsigned char* /* rxdata */, int* /* actual_rxlen */, int /* rxlen */); // Request that the auxiliary instantiates a given device, loading appropriate // support code as required. This function takes the following arguments: // 1) the location of the package that should provide this device, e.g. // devs/eth/synth // 2) the version of that package currently being used, e.g. "current" // 3) the name of the device, e.g. "ethernet". This identifies the // Tcl script that should be loaded to handle requests for this device. // 4) the name of the device instance, e.g. "eth0". // 5) device-specific initialization data. externC int synth_auxiliary_instantiate(const char*, const char*, const char*, const char*, const char*); // Support for generating strings #define SYNTH_MAKESTRING1(a) #a #define SYNTH_MAKESTRING(a) SYNTH_MAKESTRING1(a) //----------------------------------------------------------------------------- #endif // ifndef CYGONCE_HAL_HAL_IO_H // End of hal_io.h