Devtab.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_DEVTAB_HXX_
#define _FREERTOS_DRIVERS_COMMON_DEVTAB_HXX_
 
#include <dirent.h>
#include <stropts.h>
#include <sys/types.h>
#include <sys/select.h>
#include "os/OS.hxx"
 
class FileIO;
class Device;
class FileSystem;
class Notifiable;
class DeviceBufferBase;
 
struct File
{
    FileIO *dev; 
    union
    {
        void *priv; 
        void *privPtr; 
        unsigned privUint; 
        int privInt; 
    };
    off_t offset; 
    int flags;    
    uint8_t inuse  : 1; 
    uint8_t inshdn : 1; 
    uint8_t device : 1; 
    uint8_t dir    : 1; 
    uint8_t dirty  : 1; 
};
 
class FileIO
{
public:
    static ssize_t read(struct _reent *reent, int fd, void *buf, size_t count);
 
    static ssize_t write(struct _reent *reent, int fd, const void *buf, size_t count);
 
    static _off_t lseek(struct _reent *reent, int fd, _off_t offset, int whence);
 
    static int fstat(struct _reent *reent, int fd, struct stat *stat);
 
    static int ioctl(int fd, unsigned long int key, unsigned long data);
 
    static int fcntl(int fd, int cmd, unsigned long data);
 
    static bool is_device(int fd)
    {
        return file_lookup(fd)->device;
    }
 
protected:
    FileIO(const char *name)
        : name(name)
    {
    }
 
    virtual ~FileIO()
    {
    }
 
    virtual int open(File *file, const char *path, int flags, int mode) = 0;
 
    virtual int close(File *file) = 0;
 
    virtual ssize_t read(File *file, void *buf, size_t count) = 0;
 
    virtual ssize_t write(File *file, const void *buf, size_t count) = 0;
 
    virtual off_t lseek(File* f, off_t offset, int whence);
 
    virtual int fstat(File* file, struct stat *stat) = 0;
 
    virtual int ioctl(File *file, unsigned long int key, unsigned long data);
 
    virtual int fcntl(File *file, int cmd, unsigned long data);
 
    virtual bool select(File* file, int mode)
    {
        return true;
    }
 
    static int fd_alloc(void);
 
    static void fd_free(int fd);
 
    static File* file_lookup(int fd);
 
    static int fd_lookup(File *file);
 
    static const unsigned int numOpenFiles;
    
    static File files[];
 
    static OSMutex mutex;
 
    const char *name; 
    friend class Device;
 
    friend class FileSystem;
 
private:
    DISALLOW_COPY_AND_ASSIGN(FileIO);
};
 
class FileSystem : public FileIO
{
public:
    FileSystem();
 
    virtual ~FileSystem();
 
    virtual void mount(const char *mount_point) = 0;
 
    virtual void format() = 0;
 
    static int open(struct _reent *reent, const char *path, int flags,
                    int mode);
 
    static int close(struct _reent *reent, int fd);
 
    static int unlink(struct _reent *reent, const char *path);
 
    static int stat(struct _reent *reent, const char *path, struct stat *stat);
 
    static int fsync(int fd);
 
    static int closedir(DIR *dirp);
 
    static DIR *opendir(const char *name);
 
    static struct dirent *readdir(DIR *dirp);
 
protected:
    virtual int unlink(const char *path) = 0;
 
    virtual int fstat(File* file, struct stat *stat) override;
 
    virtual int stat(const char *path, struct stat *stat) = 0;
 
    virtual int fsync(File *file) = 0;
 
    virtual int closedir(File *file) = 0;
 
    virtual File *opendir(File *file, const char *name) = 0;
 
    virtual struct dirent *readdir(File *file) = 0;
 
private:
    static FileSystem *fs_lookup(const char *path);
 
    static FileSystem *first;
 
    FileSystem *next;
 
    FileSystem *prev;
 
    DISALLOW_COPY_AND_ASSIGN(FileSystem);
};
 
 
struct Device : public FileIO
{
public:
    Device(const char *name);
 
    virtual ~Device();
 
    static int open(struct _reent *reent, const char *path, int flags,
                    int mode);
 
    static int close(struct _reent *reent, int fd);
 
    static int stat(struct _reent *reent, const char *path, struct stat *stat);
 
    static int select(int nfds, fd_set *readfds, fd_set *writefds,
                      fd_set *exceptfds, long long timeout);
 
    static void select_clear();
 
protected:
    struct SelectInfo
    {
        SelectInfo()
            : event(0)
        {
        }
 
        OSEventType event;
    };
 
    virtual mode_t get_mode()
    {
        return 0;
    }
 
    static void select_insert(SelectInfo *info);
 
    static void select_wakeup(SelectInfo *info);
 
    static void select_wakeup_from_isr(SelectInfo *info, int *woken);
 
    friend class DeviceBufferBase;
 
    friend class OSSelectWakeup;
 
private:
    static Device *first;
 
    Device *next;
 
    Device *prev;
 
    DISALLOW_COPY_AND_ASSIGN(Device);
};
 
class Node : public Device
{
protected:
    Node(const char *name)
        : Device(name)
        , mode_(0)
        , references_(0)
    {
    }
 
    virtual ~Node()
    {
    }
 
    virtual void enable() = 0;
    virtual void disable() = 0;
 
    virtual void flush_buffers() = 0;
 
    int open(File *, const char *, int, int) OVERRIDE;
    int close(File *) OVERRIDE;
 
    virtual int fstat(File* file, struct stat *stat) override;
 
    OSMutex lock_; 
    mode_t mode_;
 
    unsigned int references_; 
private:
    mode_t get_mode() override
    {
        return mode_;
    }
 
    DISALLOW_COPY_AND_ASSIGN(Node);
};
 
 
class NonBlockNode : public Node
{
protected:
    NonBlockNode(const char *name)
        : Node(name)
        , readableNotify_(NULL)
        , writableNotify_(NULL) {}
 
    virtual bool has_rx_buffer_data() = 0;
    virtual bool has_tx_buffer_space() = 0;
 
    int ioctl(File *file, unsigned long int key, unsigned long data) OVERRIDE;
 
    Notifiable* readableNotify_;
    Notifiable* writableNotify_;
};
 
#endif /* _FREERTOS_DRIVERS_COMMON_DEVTAB_HXX_ */