libio.h

来自「AMLOGIC DPF source code」· C头文件 代码 · 共 658 行 · 第 1/2 页

   */
  char                                  *dev;
};

/*
 *  Valid AVFS file systems options
 */

typedef enum
{
  AVFS_FILESYSTEM_READ_ONLY,
  AVFS_FILESYSTEM_READ_WRITE,
  AVFS_FILESYSTEM_BAD_OPTIONS
} avfs_filesystem_options_t;


/*
 *  An open file data structure, indexed by 'fd'
 *  TODO:
 *     should really have a separate per/file data structure that this
 *     points to (eg: size, offset, driver, pathname should be in that)
 */

struct avfs_libio_tt {
    avfs_driver_name_t              *driver;
    off_t                             size;      /* size of file */
    off_t                             offset;    /* current offset into file */
    unsigned32                        flags;
    avfs_filesystem_location_info_t  pathinfo;
    Objects_Id                        sem;      
    unsigned32                        data0;     /* private to "driver" */
    void                             *data1;     /* ... */
    void                             *file_info; /* used by file handlers */
    avfs_filesystem_file_handlers_r *handlers;  /* type specific handlers */
};

/*
 *  param block for read/write
 *  Note: it must include 'offset' instead of using iop's offset since
 *        we can have multiple outstanding i/o's on a device.
 */

typedef struct {
    avfs_libio_t          *iop;
    off_t                   offset;
    unsigned8              *buffer;
    unsigned32              count;
    unsigned32              flags;
    unsigned32              bytes_moved;
} avfs_libio_rw_args_t;

/*
 *  param block for open/close
 */

typedef struct {
    avfs_libio_t          *iop;
    unsigned32              flags;
    unsigned32              mode;
} avfs_libio_open_close_args_t;

/*
 *  param block for ioctl
 */

typedef struct {
    avfs_libio_t          *iop;
    unsigned32              command;
    void                   *buffer;
    unsigned32              ioctl_return;
} avfs_libio_ioctl_args_t;

/*
 *  Values for 'flag'
 */

#define LIBIO_FLAGS_NO_DELAY      0x0001  /* return immediately if no data */
#define LIBIO_FLAGS_READ          0x0002  /* reading */
#define LIBIO_FLAGS_WRITE         0x0004  /* writing */
#define LIBIO_FLAGS_OPEN          0x0100  /* device is open */
#define LIBIO_FLAGS_APPEND        0x0200  /* all writes append */
#define LIBIO_FLAGS_CREATE        0x0400  /* create file */
#define LIBIO_FLAGS_CLOSE_ON_EXEC 0x0800  /* close on process exec() */
#define LIBIO_FLAGS_UNMOUNT       0x8000  /* file is unmounted */
#define LIBIO_FLAGS_READ_WRITE    (LIBIO_FLAGS_READ | LIBIO_FLAGS_WRITE)

void avfs_libio_init(void);

/*
 *  External I/O handlers
 */

typedef int (*avfs_libio_open_t)(
  const char  *pathname,
  unsigned32  flag,
  unsigned32  mode
);

typedef int (*avfs_libio_close_t)(
  int  fd
);

typedef int (*avfs_libio_read_t)(
  int         fd,
  void       *buffer,
  unsigned32  count
);

typedef int (*avfs_libio_write_t)(
  int         fd,
  const void *buffer,
  unsigned32  count
);

typedef int (*avfs_libio_ioctl_t)(
  int         fd,
  unsigned32  command,
  void       *buffer
);

typedef int (*avfs_libio_lseek_t)(
  int    fd,
  off_t  offset,
  int    whence
);

/*
 *  The following macros are used to build up the permissions sets
 *  used to check permissions.  These are similar in style to the
 *  mode_t bits and should stay compatible with them.
 */

#define AVFS_LIBIO_PERMS_READ   S_IROTH
#define AVFS_LIBIO_PERMS_WRITE  S_IWOTH
#define AVFS_LIBIO_PERMS_RDWR   (S_IROTH|S_IWOTH)
#define AVFS_LIBIO_PERMS_EXEC   S_IXOTH
#define AVFS_LIBIO_PERMS_SEARCH AVFS_LIBIO_PERMS_EXEC
#define AVFS_LIBIO_PERMS_RWX    S_IRWXO

/*
 *  Macros
 */

#if 0
#define avfs_filesystem_make_dev_t( _major, _minor ) \
  ((((dev_t)(_major)) << 32) | (dev_t)(_minor))

#define avfs_filesystem_dev_major_t( _dev ) \
  (avfs_device_major_number) ((_dev) >> 32)

#define avfs_filesystem_dev_minor_t( _dev ) \
  (avfs_device_minor_number) ((_dev) & 0xFFFFFFFF)
#else
//porting
//#include <unistd.h>

union __avfs_dev_t {
  dev_t device;
  struct {
     avfs_device_major_number major;
     avfs_device_minor_number minor;
  } __overlay;
};

static inline dev_t avfs_filesystem_make_dev_t( 
  avfs_device_major_number _major, 
  avfs_device_minor_number _minor
)
{
  union __avfs_dev_t temp;

  temp.__overlay.major = _major;
  temp.__overlay.minor = _minor;
  return temp.device;
}

static inline avfs_device_major_number avfs_filesystem_dev_major_t(
  dev_t device
)
{
  union __avfs_dev_t temp;

  temp.device = device;
  return temp.__overlay.major;
}


static inline avfs_device_minor_number avfs_filesystem_dev_minor_t(
  dev_t device
)
{
  union __avfs_dev_t temp;

  temp.device = device;
  return temp.__overlay.minor;
}

#endif

#define avfs_filesystem_split_dev_t( _dev, _major, _minor ) \
  do { \
    (_major) = avfs_filesystem_dev_major_t ( _dev ); \
    (_minor) = avfs_filesystem_dev_minor_t( _dev ); \
  } while(0)

/*
 * Verifies that the permission flag is valid.
 */
#define avfs_libio_is_valid_perms( _perm )     \
 (~ ((~AVFS_LIBIO_PERMS_RWX) & _perm ))


/*
 *  Prototypes for filesystem
 */

void avfs_filesystem_initialize( void );


/*
 * Callbacks from TERMIOS routines to device-dependent code
 */

// porting
//#include <termios.h>
#if 0
//porting
typedef struct avfs_termios_callbacks {
  int    (*firstOpen)(int major, int minor, void *arg);
  int    (*lastClose)(int major, int minor, void *arg);
  int    (*pollRead)(int minor);
  int    (*write)(int minor, const char *buf, int len);
  int    (*setAttributes)(int minor, const struct termios *t);
  int    (*stopRemoteTx)(int minor);
  int    (*startRemoteTx)(int minor);
  int    outputUsesInterrupts;
} avfs_termios_callbacks;

/*
 *  Device-independent TERMIOS routines
 */

void avfs_termios_initialize (void);

/*
 * CCJ: Change before opening a tty. Newer code from Eric is coming
 * so extra work to handle an open tty is not worth it. If the tty
 * is open, close then open it again.
 */
avfs_status_code avfs_termios_bufsize (
  int cbufsize,     /* cooked buffer size */
  int raw_input,    /* raw input buffer size */
  int raw_output    /* raw output buffer size */
);

avfs_status_code avfs_termios_open (
  avfs_device_major_number      major,
  avfs_device_minor_number      minor,
  void                          *arg,
  const avfs_termios_callbacks *callbacks
);

avfs_status_code avfs_termios_close(
  void *arg
);

avfs_status_code avfs_termios_read(
  void *arg
);

avfs_status_code avfs_termios_write(
  void *arg
);

avfs_status_code avfs_termios_ioctl(
  void *arg
);

int avfs_termios_enqueue_raw_characters(
  void *ttyp,
  char *buf,
  int   len
);

int avfs_termios_dequeue_characters(
  void *ttyp,
  int   len
);

void avfs_termios_reserve_resources(
#if 0
//porting
  avfs_configuration_table *configuration,
#endif
  avfs_unsigned32           number_of_devices
);
#endif

int unmount(
  const char *mount_path
);

int mount(
  avfs_filesystem_mount_table_entry_t **mt_entry,
  avfs_filesystem_operations_table    *fs_ops,
  avfs_filesystem_options_t            fsoptions,
  char                                 *device,
  char                                 *mount_point
);

/*
 *  Boot Time Mount Table Structure
 */

typedef struct {
  avfs_filesystem_operations_table     *fs_ops;
  avfs_filesystem_options_t             fsoptions;
  char                                  *device;
  char                                  *mount_point;
} avfs_filesystem_mount_table_t;

extern avfs_filesystem_mount_table_t *avfs_filesystem_mount_table;
extern int                             avfs_filesystem_mount_table_size;

extern void AVShell_CommandRegister(	char	*keywd,	char* help, void (*cmdfun)() );
extern void AVShell_MountTypeRegister(avfs_filesystem_operations_table* fs_ops, avfs_filesystem_options_t fs_option);

#endif /* _AVFS_LIBIO_H */