RFC HAL I2C: Reference implementations for K64F and STM32F0

drivers/I2C.cpp

@@ -32,7 +32,7 @@ SingletonPtr<PlatformMutex> I2C::_mutex;
 
 I2C::I2C(PinName sda, PinName scl) :
 #if DEVICE_I2C_ASYNCH
-    _irq(this), _usage(DMA_USAGE_NEVER), _deep_sleep_locked(false),
+    _irq(this), _deep_sleep_locked(false),
 #endif
     _i2c(), _hz(100000)
 {
@@ -41,7 +41,9 @@ I2C::I2C(PinName sda, PinName scl) :
     _sda = sda;
     _scl = scl;
     recover(sda, scl);
-    i2c_init(&_i2c, _sda, _scl);
+    i2c_init(&_i2c, sda, scl, false);
+    i2c_frequency(&_i2c, _hz);
+
     // Used to avoid unnecessary frequency updates
     _owner = this;
     unlock();
@@ -50,7 +52,7 @@ I2C::I2C(PinName sda, PinName scl) :
 void I2C::frequency(int hz)
 {
     lock();
-    _hz = hz;
+    _hz = (uint32_t)hz;
 
     // We want to update the frequency even if we are already the bus owners
     i2c_frequency(&_i2c, _hz);
@@ -77,7 +79,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, (void *)data, length, stop);
 
     unlock();
     return length != written;
@@ -86,7 +88,7 @@ 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);
+    int ret = i2c_write(&_i2c, 0, (void *)&data, 1, false);
     unlock();
     return ret;
 }
@@ -108,11 +110,7 @@ int I2C::read(int ack)
 {
     lock();
     int ret;
-    if (ack) {
-        ret = i2c_byte_read(&_i2c, 0);
-    } else {
-        ret = i2c_byte_read(&_i2c, 1);
-    }
+    i2c_read(&_i2c, 0, &ret, 1, (ack == 0));
     unlock();
     return ret;
 }
@@ -191,40 +189,17 @@ 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)) {
-        unlock();
-        return -1; // transaction ongoing
-    }
-    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);
-    unlock();
     return 0;
 }
 
 void I2C::abort_transfer(void)
 {
     lock();
-    i2c_abort_asynch(&_i2c);
-    unlock_deep_sleep();
     unlock();
 }
 
 void I2C::irq_handler_asynch(void)
 {
-    int event = i2c_irq_handler_asynch(&_i2c);
-    if (_callback && event) {
-        _callback.call(event);
-    }
-
-    if (event) {
-        unlock_deep_sleep();
-    }
 }
 
 void I2C::lock_deep_sleep()

drivers/I2C.h

@@ -210,7 +210,6 @@ class I2C : private NonCopyable<I2C> {
     void irq_handler_asynch(void);
     event_callback_t _callback;
     CThunk<I2C> _irq;
-    DMAUsage _usage;
     bool _deep_sleep_locked;
 #endif
 #endif
@@ -221,7 +220,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

@@ -22,9 +22,8 @@ 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);
 }
 
 void I2CSlave::frequency(int hz)
@@ -35,39 +34,43 @@ void I2CSlave::frequency(int hz)
 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, data, length, false) != length;
 }
 
 int I2CSlave::read(void)
 {
-    return i2c_byte_read(&_i2c, 0);
+    int 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, data, length, false) != length;
 }
 
 int I2CSlave::write(int data)
 {
-    return i2c_byte_write(&_i2c, data);
+    return i2c_write(&_i2c, 0, (void *)&data, 1, false);
 }
 
 void I2CSlave::stop(void)
 {
     i2c_stop(&_i2c);
 }
 
-}
+} // namespace mbed
 
-#endif
+#endif // DEVICE_I2CSLAVE

drivers/I2CSlave.h

@@ -154,6 +154,8 @@ class I2CSlave {
 #if !defined(DOXYGEN_ONLY)
 
 protected:
+    PinName _sda;
+    PinName _scl;
     /* Internal i2c object identifying the resources */
     i2c_t _i2c;