wire: adding support for I2C RESTART and some minor clean-ups

- Added support for sending repeated-START conditions on the I2C bus
  By adding an option to not send a STOP condition at the end of a
  transfer, it is possible for the I2C master to hold the bus and
  send additional transfers.  If switching from writing to reading,
  or vice-versa, the I2C master controller will automatically send
  a repeated-START (RESTART) in between.  For consecutive writes or
  consecutive reads to the same slave, a repeated-START is not needed.

- Cleaned up some redundant code and removed some unsupported methods
  in the Wire library implementation for AtlasEdge, particularly those
  related to I2C Slave-mode.  AtlasEdge supports I2C Master-mode only.

Signed-off-by: Dan O'Donovan <dan@emutex.com>

Author: Dan-Lightsource

cores/arduino/i2c.c

@@ -23,12 +23,7 @@
 #include "i2c.h"
 #include "variant.h"
 
-#define TIMEOUT 16
-
-int i2c_getadapter(uint32_t i2c_bus_address)
-{
-	return 0;
-}
+#define TIMEOUT_MS 16
 
 static volatile uint8_t i2c_tx_complete;
 static volatile uint8_t i2c_rx_complete;
@@ -51,50 +46,60 @@ static void ss_i2c_err(uint32_t dev_id)
 	i2c_err_detect = 1;
 }
 
-static int wait_rx_or_err(){
-	uint64_t timeout = TIMEOUT;
+static int wait_rx_or_err(bool no_stop){
+	uint64_t timeout = TIMEOUT_MS;
 	while(timeout--) {
 		if (i2c_err_detect) {
 			return I2C_ERROR;
 		}
-		if (i2c_rx_complete) {
-			return I2C_OK;
+		if (!no_stop) {
+			if (i2c_rx_complete) {
+				return I2C_OK;
+			}
 		}
 		delay(1);
 	}
-	return I2C_TIMEOUT;
+	if (!no_stop)
+		return I2C_TIMEOUT;
+	else
+		return I2C_OK;
 }
 
-static int wait_tx_or_err(){
-	uint64_t timeout = TIMEOUT;
+static int wait_tx_or_err(bool no_stop){
+	uint64_t timeout = TIMEOUT_MS;
 	while(timeout--) {
 		if (i2c_err_detect) {
 			return I2C_ERROR;
 		}
-		if (i2c_tx_complete) {
+		if (!no_stop) {
+			if (i2c_tx_complete) {
 			return I2C_OK;
+			}
 		}
 		delay(1);
 	}
-	return I2C_TIMEOUT;
+	if (!no_stop)
+		return I2C_TIMEOUT;
+	else
+		return I2C_OK;
 }
 
-static int wait_dev_ready(I2C_CONTROLLER controller_id){
-	uint64_t timeout = TIMEOUT;
+static int wait_dev_ready(I2C_CONTROLLER controller_id, bool no_stop){
+	uint64_t timeout = TIMEOUT_MS;
 	while(timeout--) {
-		int ret = ss_i2c_status(controller_id);
+		int ret = ss_i2c_status(controller_id, no_stop);
 		if (ret == I2C_OK) {
-				return I2C_OK;
+			return I2C_OK;
 		}
 		if (ret == I2C_BUSY) {
-				delay(1);
+			delay(1);
 		}
 	}
 	return I2C_TIMEOUT;
 }
 
 
-int i2c_openadapter(uint8_t i2c_adapter_nr)
+int i2c_openadapter(void)
 {
 	int ret;
 
@@ -106,7 +111,7 @@ int i2c_openadapter(uint8_t i2c_adapter_nr)
 
 	i2c_cfg_data_t i2c_cfg;
 
-	i2c_cfg.speed = I2C_FAST;
+	i2c_cfg.speed = I2C_SLOW;
 	i2c_cfg.addressing_mode = I2C_7_Bit;
 	i2c_cfg.mode_type = I2C_MASTER;
 	i2c_cfg.cb_tx = ss_i2c_tx;
@@ -117,9 +122,9 @@ int i2c_openadapter(uint8_t i2c_adapter_nr)
 	i2c_rx_complete = 0;
 	i2c_err_detect = 0;
 
-	ss_i2c_set_config(i2c_adapter_nr, &i2c_cfg);
-	ss_i2c_clock_enable(i2c_adapter_nr);
-	ret = wait_dev_ready(i2c_adapter_nr);
+	ss_i2c_set_config(I2C_SENSING_0, &i2c_cfg);
+	ss_i2c_clock_enable(I2C_SENSING_0);
+	ret = wait_dev_ready(I2C_SENSING_0, false);
 
 	return ret;
 }
@@ -130,87 +135,34 @@ void i2c_setslave(uint8_t addr)
 	return;
 }
 
-int i2c_writebyte(uint8_t byte)
+int i2c_writebytes(uint8_t *bytes, uint8_t length, bool no_stop)
 {
-	unsigned char *ch = &byte;
 	int ret;
 
 	i2c_tx_complete = 0;
 	i2c_err_detect = 0;
-	ss_i2c_write(I2C_SENSING_0, ch, 1,  i2c_slave);
-
-	ret = wait_tx_or_err();
+	ss_i2c_transfer(I2C_SENSING_0, bytes, length, 0, 0, i2c_slave, no_stop);
+	ret = wait_tx_or_err(no_stop);
 	if (ret)
 		return ret;
-
-	ret = wait_dev_ready(I2C_SENSING_0);
-	if (ret)
-		return ret;
-	return 1; /* number of bytes */
-}
-
-int i2c_writebytes(uint8_t *bytes, uint8_t length)
-{
-	int ret;
-
-	i2c_tx_complete = 0;
-	i2c_err_detect = 0;
-	ss_i2c_write(I2C_SENSING_0, bytes,  length,  i2c_slave);
-	ret = wait_tx_or_err();
-	if (ret)
-		return ret;
-	ret = wait_dev_ready(I2C_SENSING_0);
+	ret = wait_dev_ready(I2C_SENSING_0, no_stop);
 	if (ret)
 		return ret;
 	return length;
 }
 
-int i2c_readbyte()
+int i2c_readbytes(uint8_t *buf, int length, bool no_stop)
 {
-	unsigned char byte;
 	int ret;
 
 	i2c_rx_complete = 0;
 	i2c_err_detect = 0;
-	ss_i2c_read(I2C_SENSING_0, &byte,  1,  i2c_slave);
-	ret = wait_rx_or_err();
+	ss_i2c_transfer(I2C_SENSING_0, 0, 0, buf, length, i2c_slave, no_stop);
+	ret = wait_rx_or_err(no_stop);
 	if (ret)
 		return ret;
-	ret = wait_dev_ready(I2C_SENSING_0);
-	if (ret)
-		return ret;
-	return 1; /* number of bytes */
-}
-
-int i2c_readbytes(uint8_t *buf, int length)
-{
-	int ret;
-
-	i2c_rx_complete = 0;
-	i2c_err_detect = 0;
-	ss_i2c_read(I2C_SENSING_0, buf,  length,  i2c_slave);
-	ret = wait_rx_or_err();
-	if (ret)
-		return ret;
-	ret = wait_dev_ready(I2C_SENSING_0);
+	ret = wait_dev_ready(I2C_SENSING_0, no_stop);
 	if (ret)
 		return ret;
 	return length;
 }
-
-int i2c_transferbytes(uint8_t *tx_buf, int tx_length, uint8_t *rx_buf, int rx_length)
-{
-	int ret;
-
-	i2c_tx_complete = 0;
-	i2c_rx_complete = 0;
-	i2c_err_detect = 0;
-	ss_i2c_transfer(I2C_SENSING_0, tx_buf,  tx_length,  rx_buf,  rx_length, i2c_slave);
-	ret = wait_rx_or_err();
-	if (ret)
-		return ret;
-	ret = wait_dev_ready(I2C_SENSING_0);
-	if (ret)
-		return ret;
-	return rx_length;
-}

cores/arduino/i2c.h

@@ -31,14 +31,10 @@ extern "C"{
 #define I2C_TIMEOUT -1
 #define I2C_ERROR   -2
 
-int i2c_getadapter(uint32_t i2c_bus_address);
-int i2c_openadapter(uint8_t i2c_adapter_nr);
+int i2c_openadapter(void);
 void i2c_setslave(uint8_t addr);
-int i2c_writebyte(uint8_t byte);
-int i2c_writebytes(uint8_t *bytes, uint8_t length);
-int i2c_readbyte(void);
-int i2c_readbytes(uint8_t *buf, int length);
-int i2c_transferbytes(uint8_t *tx_buf, int tx_length, uint8_t *rx_buf, int rx_length);
+int i2c_writebytes(uint8_t *bytes, uint8_t length, bool no_stop);
+int i2c_readbytes(uint8_t *buf, int length, bool no_stop);
 
 #ifdef __cplusplus
 }

libraries/Wire/Wire.cpp

@@ -17,7 +17,8 @@
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
- * Slight modifications to support Intel EDU June 2015 - dave.hunt@emutex.com
+ * Modifications to support Intel Arduino 101
+ * Copyright (C) 2015 Intel Corporation
  */
 
 extern "C" {
@@ -29,37 +30,15 @@ extern "C" {
 #include "variant.h"
 
 
-TwoWire::TwoWire(void(*_beginCb)(void)) : rxBufferIndex(0), rxBufferLength(0),
-					  txAddress(0), txBufferLength(0),
-					  srvBufferIndex(0), srvBufferLength(0),
-					  onBeginCallback(_beginCb),
-					  adapter_nr(-1), i2c_fd(-1),
-					  i2c_transfer(0)
+TwoWire::TwoWire(void) : rxBufferIndex(0), rxBufferLength(0),
+			 txBufferLength(0), init_status(-1)
 {
 	// Empty
 }
 
 void TwoWire::begin(void)
 {
-	if (onBeginCallback)
-		onBeginCallback();
-
-	adapter_nr = 0;
-	if ((i2c_fd = i2c_openadapter(adapter_nr)) < 0) {
-		return;
-	}
-
-}
-
-void TwoWire::begin(uint8_t address)
-{
-	if (onBeginCallback)
-		onBeginCallback();
-}
-
-void TwoWire::begin(int address)
-{
-	begin((uint8_t) address);
+	init_status = i2c_openadapter();
 }
 
 uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop)
@@ -70,27 +49,7 @@ uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop
 
 	/* Set slave address via ioctl  */
 	i2c_setslave(address);
-
-	if(i2c_transfer) {
-	/* Need to perform a combined read/write operation
-	 */
-		i2c_transfer = 0;
-
-		if (sendStop == false)
-			return 0;
-
-		// Call transfer fucntion.
-		if(i2c_transferbytes(txBuffer, txBufferLength, rxBuffer, quantity))
-		{
-			txBufferLength = 0;
-			rxBufferIndex = 0;
-			rxBufferLength = quantity;
-			i2c_transfer = 0;
-			return quantity;
-		} else
-			return 0;
-	}
-	ret = i2c_readbytes(rxBuffer, quantity);
+	ret = i2c_readbytes(rxBuffer, quantity, !sendStop);
 	if (ret < 0) {
 		return 0;
 	}
@@ -118,14 +77,11 @@ uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop)
 
 void TwoWire::beginTransmission(uint8_t address)
 {
-	if (i2c_fd < 0 || adapter_nr < 0)
+	if (init_status < 0)
 		return;
-	/* set slave address via ioctl in case we need to perform terminating
-	 * write operation
-	 */
+	// set slave address
 	i2c_setslave(address);
-	// save address of target and empty buffer
-	txAddress = address;
+	// reset transmit buffer
 	txBufferLength = 0;
 }
 
@@ -150,31 +106,25 @@ void TwoWire::beginTransmission(int address)
 uint8_t TwoWire::endTransmission(uint8_t sendStop)
 {
 	int err;
-	if (sendStop == true) {
-
 		// transmit buffer (blocking)
-		if (txBufferLength > 1)
-			err = i2c_writebytes(txBuffer, txBufferLength);
-		else if (txBufferLength == 1)
-			err = i2c_writebyte(*txBuffer);
-		else {
+		if (txBufferLength >= 1) {
+			err = i2c_writebytes(txBuffer, txBufferLength, !sendStop);
+		} else {
 			/* FIXME: A zero byte transmit is typically used to check for an
-			 * ACK from the slave device. I'm not sure if this is the
-			 * correct way to do this.
+			 * ACK from the slave device. This is currently not supported by
+			 * this library implementation
 			 */
-			err = i2c_readbyte();
+			return 4; // Other error
 		}
 		// empty buffer
 		txBufferLength = 0;
 		if (err < 0) {
-			return 2;
+			return 2; // NACK on transmit of address
+			/* NOTE: This implementation currently does not distinguish
+			 * between NACK on transmit of adddress or data, or other errors
+			 */
 		}
-		return 0;
-	} else {
-		/* sendStop = false */
-		i2c_transfer = 1;
-		return 0;
-	}
+		return 0; // success
 }
 
 //	This provides backwards compatibility with the original
@@ -228,25 +178,6 @@ void TwoWire::flush(void)
 	// data transfer.
 }
 
-void TwoWire::onReceive(void(*function)(int))
-{
-	onReceiveCallback = function;
-}
-
-void TwoWire::onRequest(void(*function)(void)) {
-	onRequestCallback = function;
-}
-
-void TwoWire::onService(void)
-{
-}
+// Preinstantiate Objects //////////////////////////////////////////////////////
 
-static void Wire_Init(void)
-{
-}
-
-TwoWire Wire = TwoWire(Wire_Init);
-
-void WIRE_ISR_HANDLER(void) {
-	Wire.onService();
-}
+TwoWire Wire = TwoWire();