zr-v4/libraries/AP_HAL_F4Light/I2CDevice.h

/// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
/*
 *
 * This file 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 3 of the License, or
 * (at your option) any later version.
 *
 * This file 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#pragma once

#include <inttypes.h>
#include "AP_HAL_F4Light_Namespace.h"
#include "Scheduler.h"

#include <AP_HAL/HAL.h>
#include <AP_HAL_F4Light/HAL_F4Light_Class.h>
#include <AP_HAL/I2CDevice.h>
#include <AP_HAL/utility/OwnPtr.h>
#include "Semaphores.h"

#include <i2c.h>
#include "tim_i2c.h"

#define MAX_I2C_DEVICES 10

using namespace F4Light;

#ifdef I2C_DEBUG
enum I2C_Log_State {
    I2C_START,
    I2C_ISR,
    I2C_STOP,
    I2C_ERR,
    I2C_FINISH,
};

typedef struct I2C_STATE {
    uint32_t time;
    uint8_t addr;
    uint8_t bus;
    uint8_t send_len;
    uint8_t recv_len;
    uint8_t ret;
    uint16_t cr1;
    uint16_t sr1;
    uint16_t sr2;
    uint16_t st_sr1;
    uint16_t st_sr2;
    uint8_t state;
    I2C_Log_State pos;
} I2C_State;
#endif


class F4Light::I2CDevice : public AP_HAL::I2CDevice {
public:

    I2CDevice(uint8_t bus, uint8_t address);
    
    ~I2CDevice();

    static void lateInit();

    /* AP_HAL::I2CDevice implementation */

    /* See AP_HAL::I2CDevice::set_address() */
    inline void set_address(uint8_t address) override { _address = address; }

    /* See AP_HAL::I2CDevice::set_retries() */
    inline void set_retries(uint8_t retries) override { _retries = retries; }


    /* AP_HAL::Device implementation */

    /* See AP_HAL::Device::transfer() */
    bool transfer(const uint8_t *send, uint32_t send_len,
                  uint8_t *recv, uint32_t recv_len) override;


    bool read_registers_multiple(uint8_t first_reg, uint8_t *recv,
                                 uint32_t recv_len, uint8_t times);


    /* See AP_HAL::Device::set_speed() */
    inline bool set_speed(enum AP_HAL::Device::Speed speed) override { return true; };

    /* See AP_HAL::Device::get_semaphore() */
    inline F4Light::Semaphore *get_semaphore() override { return &_semaphores[_bus]; } // numbers from 0

    /* See AP_HAL::Device::register_periodic_callback() */
    inline AP_HAL::Device::PeriodicHandle register_periodic_callback(
        uint32_t period_usec, Device::PeriodicCb proc) override
    {   
        return Scheduler::register_timer_task(period_usec, proc, get_semaphore() );
    }


    inline bool adjust_periodic_callback(
        AP_HAL::Device::PeriodicHandle h, uint32_t period_usec) override 
    {
        return Scheduler::adjust_timer_task(h, period_usec);
    }
    
    inline bool unregister_callback(PeriodicHandle h) override  { return Scheduler::unregister_timer_task(h); }

    void register_completion_callback(Handler h);

    inline void register_completion_callback(AP_HAL::MemberProc proc){
        Revo_handler r = { .mp=proc };
        register_completion_callback(r.h);
    }
    inline void register_completion_callback(AP_HAL::Proc proc){
        Revo_handler r = { .hp=proc };
        register_completion_callback(r.h);
    }

    inline uint32_t get_error_count() { return _lockup_count; }
    inline uint8_t  get_last_error() { return last_error; }
    inline uint8_t  get_last_error_state() { return last_error_state; }
    inline uint8_t  get_bus()  { return _bus; }
    inline uint8_t  get_addr() { return _address; }
    
    static inline uint8_t get_dev_count() { return dev_count; }
    static inline F4Light::I2CDevice * get_device(uint8_t i) { return devices[i]; }

    void do_bus_reset();

private:
    void init();

    uint32_t i2c_read(uint8_t addr, const uint8_t *tx_buff, uint8_t txlen, uint8_t *rx_buff, uint8_t rxlen);
    uint32_t i2c_write(uint8_t addr, const uint8_t *tx_buff, uint8_t len);
    void  isr_ev();
    uint32_t wait_stop_done(bool v);
    void finish_transfer();

    uint8_t  _bus;
    uint16_t _offs;
    uint8_t  _address;
    uint8_t  _retries;
    uint32_t _lockup_count;
    bool     _initialized;
    uint8_t  last_error;
    uint8_t  last_error_state;
    bool     _slow;
    bool     _failed;
    bool     need_reset;
    void     *_task;
    
    const i2c_dev *_dev;
    Soft_I2C *s_i2c; // per-bus instances

    static F4Light::Semaphore _semaphores[3]; // individual for each bus + softI2C
    static const timer_dev *   _timers[3];   // one timer per bus
    
    static F4Light::I2CDevice * devices[MAX_I2C_DEVICES]; // links to all created devices
    static uint8_t dev_count;
    static bool lateInitDone;
    
    Handler _completion_cb;

    uint8_t _state; // state of transfer for ISR
    volatile uint8_t _error; // error from ISR
    uint8_t _addr;      //      data for ISR
    const uint8_t *_tx_buff;
    uint8_t  _tx_len;
    uint8_t *_rx_buff;
    uint8_t  _rx_len;

    void _do_bus_reset();
    
#ifdef I2C_DEBUG
#define I2C_LOG_SIZE 99
    static I2C_State log[I2C_LOG_SIZE];
    static uint8_t log_ptr;
#endif
};

class F4Light::I2CDeviceManager : public AP_HAL::I2CDeviceManager {
    friend class F4Light::I2CDevice;

public:
    I2CDeviceManager() { }

    /* AP_HAL::I2CDeviceManager implementation */
    AP_HAL::OwnPtr<AP_HAL::I2CDevice> get_device(uint8_t bus, 
                                                uint8_t address,
                                                uint32_t bus_clock=400000,
                                                bool use_smbus = false,
                                                uint32_t timeout_ms=4) {

        // let's first check for existence of such device on same bus
        uint8_t n = I2CDevice::get_dev_count();

        for(uint8_t i=0; i<n; i++){
            I2CDevice * d = I2CDevice::get_device(i);
            if(d){
                if(d->get_bus() == bus && d->get_addr() == address) { // device already exists
                    return nullptr;
                }
            }
        }
    
        return AP_HAL::OwnPtr<AP_HAL::I2CDevice>(
            new I2CDevice(bus, address)
        );
    }
};