I2c ref impl

drivers/I2C.cpp

@@ -18,6 +18,7 @@
 #include "drivers/I2C.h"
 #include "drivers/DigitalInOut.h"
 #include "platform/mbed_wait_api.h"
+#include "platform/mbed_assert.h"
 
 #if DEVICE_I2C
 
@@ -32,7 +33,8 @@ SingletonPtr<PlatformMutex> I2C::_mutex;
 
 I2C::I2C(PinName sda, PinName scl) :
 #if DEVICE_I2C_ASYNCH
-    _irq(this), _usage(DMA_USAGE_NEVER), _deep_sleep_locked(false),
+    _deep_sleep_locked(false),
+    _async_transfer_ongoing(false),
 #endif
     _i2c(), _hz(100000)
 {
@@ -41,16 +43,24 @@ I2C::I2C(PinName sda, PinName scl) :
     _sda = sda;
     _scl = scl;
     recover(sda, scl);
-    i2c_init(&_i2c, _sda, _scl);
+    i2c_init(&_i2c, sda, scl, false);
+    frequency(_hz);
+
     // Used to avoid unnecessary frequency updates
     _owner = this;
     unlock();
 }
 
+I2C::~I2C()
+{
+    i2c_free(&_i2c);
+}
+
 void I2C::frequency(int hz)
 {
     lock();
-    _hz = hz;
+    MBED_ASSERT(_hz > 0);
+    _hz = (uint32_t)hz;
 
     // We want to update the frequency even if we are already the bus owners
     i2c_frequency(&_i2c, _hz);
@@ -60,6 +70,14 @@ void I2C::frequency(int hz)
     unlock();
 }
 
+void I2C::timeout(uint32_t timeout)
+{
+    lock();
+    i2c_timeout(&_i2c, timeout);
+    unlock();
+}
+
+
 void I2C::aquire()
 {
     lock();
@@ -77,7 +95,7 @@ int I2C::write(int address, const char *data, int length, bool repeated)
     aquire();
 
     int stop = (repeated) ? 0 : 1;
-    int written = i2c_write(&_i2c, address, data, length, stop);
+    int written = i2c_write(&_i2c, address, (const uint8_t *)data, length, stop);
 
     unlock();
     return length != written;
@@ -86,7 +104,8 @@ int I2C::write(int address, const char *data, int length, bool repeated)
 int I2C::write(int data)
 {
     lock();
-    int ret = i2c_byte_write(&_i2c, data);
+    uint8_t byte = data;
+    int ret = i2c_write(&_i2c, 0, &byte, 1, false);
     unlock();
     return ret;
 }
@@ -98,7 +117,7 @@ int I2C::read(int address, char *data, int length, bool repeated)
     aquire();
 
     int stop = (repeated) ? 0 : 1;
-    int read = i2c_read(&_i2c, address, data, length, stop);
+    int read = i2c_read(&_i2c, address, (uint8_t *)data, length, stop);
 
     unlock();
     return length != read;
@@ -107,12 +126,8 @@ int I2C::read(int address, char *data, int length, bool repeated)
 int I2C::read(int ack)
 {
     lock();
-    int ret;
-    if (ack) {
-        ret = i2c_byte_read(&_i2c, 0);
-    } else {
-        ret = i2c_byte_read(&_i2c, 1);
-    }
+    uint8_t ret;
+    i2c_read(&_i2c, 0, &ret, 1, (ack == 0));
     unlock();
     return ret;
 }
@@ -192,39 +207,38 @@ int I2C::recover(PinName sda, PinName scl)
 int I2C::transfer(int address, const char *tx_buffer, int tx_length, char *rx_buffer, int rx_length, const event_callback_t &callback, int event, bool repeated)
 {
     lock();
-    if (i2c_active(&_i2c)) {
+    if (_async_transfer_ongoing) {
         unlock();
-        return -1; // transaction ongoing
+        return -1;
     }
     lock_deep_sleep();
     aquire();
 
     _callback = callback;
-    int stop = (repeated) ? 0 : 1;
-    _irq.callback(&I2C::irq_handler_asynch);
-    i2c_transfer_asynch(&_i2c, (void *)tx_buffer, tx_length, (void *)rx_buffer, rx_length, address, stop, _irq.entry(), event, _usage);
+    bool stop = (repeated) ? false : true;
+    _async_transfer_ongoing = true;
+    i2c_transfer_async(&_i2c, (const uint8_t *)tx_buffer, tx_length, (uint8_t *)rx_buffer, rx_length, address, stop, &I2C::irq_handler_asynch, (void *)this);
     unlock();
     return 0;
 }
 
 void I2C::abort_transfer(void)
 {
     lock();
-    i2c_abort_asynch(&_i2c);
+    i2c_abort_async(&_i2c);
+    _async_transfer_ongoing = false;
     unlock_deep_sleep();
     unlock();
 }
 
-void I2C::irq_handler_asynch(void)
+void I2C::irq_handler_asynch(i2c_t *obj, i2c_async_event_t *event, void *ctx)
 {
-    int event = i2c_irq_handler_asynch(&_i2c);
-    if (_callback && event) {
-        _callback.call(event);
-    }
-
-    if (event) {
-        unlock_deep_sleep();
+    I2C *self = (I2C *)ctx;
+    if (self->_callback) {
+        self->_callback.call(event->error ? I2C_EVENT_ERROR : I2C_EVENT_TRANSFER_COMPLETE);
     }
+    self->_async_transfer_ongoing = false;
+    self->unlock_deep_sleep();
 }
 
 void I2C::lock_deep_sleep()

drivers/I2C.h

@@ -94,12 +94,26 @@ class I2C : private NonCopyable<I2C> {
      */
     I2C(PinName sda, PinName scl);
 
+    virtual ~I2C();
+
     /** Set the frequency of the I2C interface
      *
      *  @param hz The bus frequency in hertz
      */
     void frequency(int hz);
 
+    /** Configure the timeout duration in microseconds for blocking transmission
+    *
+    *  @param timeout    Transmission timeout in microseconds.
+    *
+    *  @note If no timeout is set the default timeout is used.
+    *        Default timeout value is based on I2C frequency.
+    *        Byte timeout is computed as triple amount of time it would take
+    *        to send 10bit over I2C and is expressed by the formula:
+    *        byte_timeout = 3 * (1/frequency * 10 * 1000000)
+    */
+    void timeout(uint32_t timeout);
+
     /** Read from an I2C slave
      *
      * Performs a complete read transaction. The bottom bit of
@@ -170,11 +184,6 @@ class I2C : private NonCopyable<I2C> {
      */
     virtual void unlock(void);
 
-    virtual ~I2C()
-    {
-        // Do nothing
-    }
-
 #if DEVICE_I2C_ASYNCH
 
     /** Start nonblocking I2C transfer.
@@ -207,11 +216,10 @@ class I2C : private NonCopyable<I2C> {
     /** Unlock deep sleep only if it has been locked */
     void unlock_deep_sleep();
 
-    void irq_handler_asynch(void);
+    static void irq_handler_asynch(i2c_t *obj, i2c_async_event_t *event, void *ctx);
     event_callback_t _callback;
-    CThunk<I2C> _irq;
-    DMAUsage _usage;
     bool _deep_sleep_locked;
+    bool _async_transfer_ongoing;
 #endif
 #endif
 
@@ -221,7 +229,7 @@ class I2C : private NonCopyable<I2C> {
 
     i2c_t _i2c;
     static I2C  *_owner;
-    int    _hz;
+    uint32_t _hz;
     static SingletonPtr<PlatformMutex> _mutex;
     PinName _sda;
     PinName _scl;

drivers/I2CSlave.cpp

@@ -14,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "platform/mbed_assert.h"
 #include "drivers/I2CSlave.h"
 
 #if DEVICE_I2CSLAVE
@@ -22,52 +23,67 @@ namespace mbed {
 
 I2CSlave::I2CSlave(PinName sda, PinName scl) : _i2c()
 {
-    i2c_init(&_i2c, sda, scl);
+    i2c_init(&_i2c, sda, scl, true);
     i2c_frequency(&_i2c, 100000);
-    i2c_slave_mode(&_i2c, 1);
+}
+
+I2CSlave::~I2CSlave()
+{
+    i2c_free(&_i2c);
 }
 
 void I2CSlave::frequency(int hz)
 {
-    i2c_frequency(&_i2c, hz);
+    MBED_ASSERT(hz > 0);
+    i2c_frequency(&_i2c, (uint32_t)hz);
+}
+
+void I2CSlave::timeout(uint32_t timeout)
+{
+    i2c_timeout(&_i2c, timeout);
 }
 
 void I2CSlave::address(int address)
 {
     int addr = (address & 0xFF) | 1;
-    i2c_slave_address(&_i2c, 0, addr, 0);
+
+    i2c_slave_address(&_i2c, addr);
 }
 
 int I2CSlave::receive(void)
 {
-    return i2c_slave_receive(&_i2c);
+    return i2c_slave_status(&_i2c);
 }
 
 int I2CSlave::read(char *data, int length)
 {
-    return i2c_slave_read(&_i2c, data, length) != length;
+    return i2c_read(&_i2c, 0, (uint8_t *)data, length, false) != length;
 }
 
 int I2CSlave::read(void)
 {
-    return i2c_byte_read(&_i2c, 0);
+    uint8_t ret;
+    i2c_read(&_i2c, 0, &ret, 1, false);
+
+    return ret;
 }
 
 int I2CSlave::write(const char *data, int length)
 {
-    return i2c_slave_write(&_i2c, data, length) != length;
+    return i2c_write(&_i2c, 0, (const uint8_t *)data, length, false) != length;
 }
 
 int I2CSlave::write(int data)
 {
-    return i2c_byte_write(&_i2c, data);
+    uint8_t byte = data;
+    return i2c_write(&_i2c, 0, &byte, 1, false);
 }
 
 void I2CSlave::stop(void)
 {
     i2c_stop(&_i2c);
 }
 
-}
+} // namespace mbed
 
-#endif
+#endif // DEVICE_I2CSLAVE

drivers/I2CSlave.h

@@ -22,6 +22,7 @@
 #if DEVICE_I2CSLAVE || defined(DOXYGEN_ONLY)
 
 #include "hal/i2c_api.h"
+#include "platform/NonCopyable.h"
 
 namespace mbed {
 /** \addtogroup drivers */
@@ -66,7 +67,7 @@ namespace mbed {
  * @endcode
  * @ingroup drivers
  */
-class I2CSlave {
+class I2CSlave : private NonCopyable<I2CSlave> {
 
 public:
     enum RxStatus {
@@ -83,12 +84,26 @@ class I2CSlave {
      */
     I2CSlave(PinName sda, PinName scl);
 
+    virtual ~I2CSlave();
+
     /** Set the frequency of the I2C interface.
      *
      *  @param hz The bus frequency in Hertz.
      */
     void frequency(int hz);
 
+    /** Configure the timeout duration in microseconds for blocking transmission
+    *
+    *  @param timeout    Transmission timeout in microseconds.
+    *
+    *  @note If no timeout is set the default timeout is used.
+    *        Default timeout value is based on I2C frequency.
+    *        Byte timeout is computed as triple amount of time it would take
+    *        to send 10bit over I2C and is expressed by the formula:
+    *        byte_timeout = 3 * (1/frequency * 10 * 1000000)
+    */
+    void timeout(uint32_t timeout);
+
     /** Check if this I2C Slave has been addressed.
      *
      *  @return A status indicating if the device has been addressed and how.
@@ -154,6 +169,8 @@ class I2CSlave {
 #if !defined(DOXYGEN_ONLY)
 
 protected:
+    PinName _sda;
+    PinName _scl;
     /* Internal i2c object identifying the resources */
     i2c_t _i2c;