MCP23017Gpio.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_MCP23017GPIO_HXX_
#define _FREERTOS_DRIVERS_COMMON_MCP23017GPIO_HXX_
 
#include <fcntl.h>
#include <unistd.h>
#include "i2c.h"
#include "i2c-dev.h"
 
#include "executor/Executor.hxx"
 
class MCP23017 : private Atomic
{
public:
    // 50 Hz polling
    static constexpr long long POLLING_DELAY = MSEC_TO_NSEC(20);
 
    MCP23017(ExecutorBase *executor, bool a2, bool a1, bool a0)
        : executor_(executor)
    {
        unsigned num = 0;
        if (a2)
        {
            num |= 0b100;
        }
        if (a1)
        {
            num |= 0b010;
        }
        if (a0)
        {
            num |= 0b001;
        }
        i2cAddress_ = BASE_ADDRESS | num;
    }
 
    void init(const char *i2c_path)
    {
        int fd = ::open(i2c_path, O_RDWR);
        HASSERT(fd >= 0);
        init(fd);
    }
 
    void init(int i2c_fd)
    {
        fd_ = i2c_fd;
 
        dir_[0] = dir_[1] = 0xff;
        dirty_ = DIRTY_DIR;
        update_out();
        update_in();
 
        timer_.start(POLLING_DELAY);
    }
 
    enum
    {
        PORTA = 0,
        PORTB = 1,
    };
 
private:
    DISALLOW_COPY_AND_ASSIGN(MCP23017);
 
    friend class MCP23017Gpio;
 
    enum Registers
    {
        IODIRA = 0x0,
        IODIRB = 0x1,
        IPOLA = 0x2,
        IPOLB = 0x3,
        GPINTENA = 0x4,
        GPINTENB = 0x5,
        DEFVALA = 0x6,
        DEFVALB = 0x7,
        INTCONA = 0x8,
        INTCONB = 0x9,
        IOCON = 0xA,
        GPPUA = 0xC,
        GPPUB = 0xD,
        INTFA = 0xE,
        INTFB = 0xF,
        INTCAPA = 0x10,
        INTCAPB = 0x11,
        RGPIOA = 0x12,
        RGPIOB = 0x13,
        OLATA = 0x14,
        OLATB = 0x15
    };
 
    enum
    {
        BASE_ADDRESS = 0b0100000,
 
        DIRTY_DIR = 1,
        DIRTY_LAT = 2,
    };
 
    void update_out()
    {
        bool push_dir = false;
        bool push_lat = false;
        uint8_t d[2];
        uint8_t l[2];
        {
            AtomicHolder h(this);
            d[0] = dir_[0];
            d[1] = dir_[1];
            l[0] = lat_[0];
            l[1] = lat_[1];
            if (dirty_ & DIRTY_DIR)
            {
                dirty_ &= ~DIRTY_DIR;
                push_dir = true;
            }
            if (dirty_ & DIRTY_LAT)
            {
                dirty_ &= ~DIRTY_LAT;
                push_lat = true;
            }
        }
        if (push_dir)
        {
            register_write(IODIRA, d, 2);
        }
        if (push_lat)
        {
            register_write(OLATA, l, 2);
        }
    }
 
    void update_in()
    {
        register_read(RGPIOA, gpio_, 2);
    }
 
    void register_write(uint8_t reg, const uint8_t *data, uint16_t len)
    {
        uint8_t dat[3];
        dat[0] = reg;
        dat[1] = data[0];
        if (len > 1)
        {
            dat[2] = data[1];
        }
        HASSERT(len <= 2);
        struct i2c_msg msgs[] = {{.addr = i2cAddress_,
            .flags = 0,
            .len = (uint16_t)(len + 1),
            .buf = dat}};
 
        struct i2c_rdwr_ioctl_data ioctl_data = {
            .msgs = msgs, .nmsgs = ARRAYSIZE(msgs)};
 
        ::ioctl(fd_, I2C_RDWR, &ioctl_data);
    }
 
    void register_read(uint8_t reg, uint8_t *data, uint16_t len)
    {
        struct i2c_msg msgs[] = {
            {.addr = i2cAddress_, .flags = 0, .len = 1, .buf = &reg},
            {.addr = i2cAddress_, .flags = I2C_M_RD, .len = len, .buf = data}};
 
        struct i2c_rdwr_ioctl_data ioctl_data = {
            .msgs = msgs, .nmsgs = ARRAYSIZE(msgs)};
 
        ::ioctl(fd_, I2C_RDWR, &ioctl_data);
    }
 
    class RefreshTimer : public ::Timer
    {
    public:
        RefreshTimer(MCP23017 *parent)
            : ::Timer(parent->executor_->active_timers())
            , parent_(parent)
        {
        }
 
        long long timeout() override
        {
            parent_->update_out();
            parent_->update_in();
            return RESTART;
        };
 
    private:
        MCP23017 *parent_;
    };
 
    ExecutorBase *executor_;
    RefreshTimer timer_{this};
    int fd_;
 
    uint8_t dir_[2];
    uint8_t lat_[2];
    uint8_t gpio_[2];
 
    uint8_t i2cAddress_;
 
    uint8_t dirty_ = 0;
};
 
class MCP23017Gpio : public Gpio
{
public:
    constexpr MCP23017Gpio(MCP23017 *const parent, unsigned port, unsigned pin)
        : parent_(parent)
        , port_(port)
        , pinBit_(1 << pin)
    {
    }
 
    void set() const override
    {
        write(VHIGH);
    }
 
    void clr() const override
    {
        write(VLOW);
    }
 
    void write(Value new_state) const override
    {
        AtomicHolder h(parent_);
        bool old_state = !!(parent_->lat_[port_] & pinBit_);
        if (new_state != old_state)
        {
            if (new_state)
            {
                parent_->lat_[port_] |= pinBit_;
            }
            else
            {
                parent_->lat_[port_] &= ~pinBit_;
            }
            parent_->dirty_ |= parent_->DIRTY_LAT;
        }
    }
 
    Value read() const override
    {
        if (parent_->dir_[port_] & pinBit_)
        {
            // input. Use gpio_.
            return (parent_->gpio_[port_] & pinBit_) ? VHIGH : VLOW;
        }
        else
        {
            // output. Use lat_.
            return (parent_->lat_[port_] & pinBit_) ? VHIGH : VLOW;
        }
    }
 
    void set_direction(Direction dir) const override
    {
        AtomicHolder h(parent_);
        uint8_t desired = (dir == Direction::DOUTPUT) ? 0 : pinBit_;
        if (desired != ((parent_->dir_[port_] & pinBit_)))
        {
            parent_->dir_[port_] =
                (parent_->dir_[port_] & (~pinBit_)) | desired;
            parent_->dirty_ |= parent_->DIRTY_DIR;
        }
    }
 
    Direction direction() const override
    {
        if (parent_->dir_[port_] & pinBit_)
        {
            return Direction::DINPUT;
        }
        else
        {
            return Direction::DOUTPUT;
        }
    }
 
private:
    DISALLOW_COPY_AND_ASSIGN(MCP23017Gpio);
 
    MCP23017 *const parent_;
    const uint8_t port_;
    const uint8_t pinBit_;
};
 
#endif // _FREERTOS_DRIVERS_COMMON_MCP23017GPIO_HXX_