support lakemont I2C controller master mode

Author: Xie,Qi

cores/arduino/i2c.h

@@ -29,24 +29,24 @@
 extern "C" {
 #endif
 
-#define I2C_OK 0
+#define I2C_OK       0
 #define I2C_TIMEOUT -10
-#define I2C_ERROR -20
+#define I2C_ERROR   -20
 #define I2C_ERROR_ADDRESS_NOACK (-2)
-#define I2C_ERROR_DATA_NOACK (-3)
-#define I2C_ERROR_OTHER (-4)
+#define I2C_ERROR_DATA_NOACK    (-3)
+#define I2C_ERROR_OTHER         (-4)
 
-#define I2C_ABRT_7B_ADDR_NOACK (1 << 0)
-#define I2C_ABRT_TXDATA_NOACK (1 << 3)
+#define I2C_ABRT_7B_ADDR_NOACK  (1 << 0)
+#define I2C_ABRT_TXDATA_NOACK   (1 << 3)
 
 int i2c_openadapter(void);
 int i2c_openadapter_speed(int);
 void i2c_setslave(uint8_t addr);
 int i2c_writebytes(uint8_t *bytes, uint8_t length, bool no_stop);
 int i2c_readbytes(uint8_t *buf, int length, bool no_stop);
 
-int soc_i2c_openadapter(uint8_t address);
-void soc_i2c_setslave(uint8_t addr);
+int soc_i2c_openadapter(uint32_t address,int i2c_speed,int i2c_addr_mode);
+void soc_i2c_master_set_slave_address(uint32_t addr);
 int soc_i2c_master_witebytes(uint8_t *bytes, uint8_t length, bool no_stop);
 int soc_i2c_master_readbytes(uint8_t *buf, int length, bool no_stop);
 void soc_i2c_slave_set_rx_user_callback(void (*onReceiveCallback)(int));

cores/arduino/soc_i2c.c

@@ -31,45 +31,53 @@ static volatile uint8_t soc_i2c_master_rx_complete;
 static volatile uint8_t soc_i2c_err_detect;
 static volatile uint32_t soc_i2c_err_source;
 
-static volatile uint8_t soc_i2c_slave = 0;
+static volatile uint32_t soc_i2c_slave_address = 0;
 
-static void soc_i2c_master_rx_callback(uint32_t dev_id) {
+static void soc_i2c_master_rx_callback(uint32_t dev_id)
+{
     soc_i2c_master_rx_complete = 1;
 }
 
-static void soc_i2c_master_tx_callback(uint32_t dev_id) {
+static void soc_i2c_master_tx_callback(uint32_t dev_id)
+{
     soc_i2c_master_tx_complete = 1;
 }
 
-static void soc_i2c_err_callback(uint32_t dev_id) {
+static void soc_i2c_err_callback(uint32_t dev_id)
+{
     soc_i2c_err_detect = 1;
     soc_i2c_err_source = dev_id;
 }
 
 static void (*soc_i2c_slave_rx_user_callback)(int) = NULL;
 static void (*soc_i2c_slave_tx_user_callback)(void) = NULL;
 
-static void soc_i2c_slave_rx_callback(uint32_t bytes) {
+static void soc_i2c_slave_rx_callback(uint32_t bytes)
+{
     if (soc_i2c_slave_rx_user_callback) {
         soc_i2c_slave_rx_user_callback((int)bytes);
     }
 }
 
-static void soc_i2c_slave_tx_callback(uint32_t bytes) {
+static void soc_i2c_slave_tx_callback(uint32_t bytes)
+{
     if (soc_i2c_slave_tx_user_callback) {
         soc_i2c_slave_tx_user_callback();
     }
 }
 
-void soc_i2c_slave_set_rx_user_callback(void (*onReceiveCallback)(int)) {
+void soc_i2c_slave_set_rx_user_callback(void (*onReceiveCallback)(int))
+{
     soc_i2c_slave_rx_user_callback = onReceiveCallback;
 }
 
-void soc_i2c_slave_set_tx_user_callback(void (*onRequestCallback)(void)) {
+void soc_i2c_slave_set_tx_user_callback(void (*onRequestCallback)(void))
+{
     soc_i2c_slave_tx_user_callback = onRequestCallback;
 }
 
-static int soc_i2c_master_wait_rx_or_err() {
+static int soc_i2c_master_wait_rx_or_err()
+{
     uint64_t timeout = TIMEOUT_MS * 200;
     while (timeout--) {
         if (soc_i2c_err_detect) {
@@ -89,7 +97,8 @@ static int soc_i2c_master_wait_rx_or_err() {
     return I2C_TIMEOUT;
 }
 
-static int soc_i2c_master_wait_tx_or_err() {
+static int soc_i2c_master_wait_tx_or_err()
+{
     uint64_t timeout = TIMEOUT_MS * 200;
     while (timeout--) {
         if (soc_i2c_err_detect) {
@@ -110,11 +119,12 @@ static int soc_i2c_master_wait_tx_or_err() {
 }
 
 static int soc_i2c_wait_dev_ready(SOC_I2C_CONTROLLER controller_id,
-                                  bool no_stop) {
+                                  bool no_stop)
+{
     uint64_t timeout = TIMEOUT_MS * 200;
     int ret = 0;
     while (timeout--) {
-        ret = soc_i2c_status(controller_id);
+        ret = soc_i2c_status(controller_id, no_stop);
         if (ret == I2C_OK) {
             return I2C_OK;
         }
@@ -125,8 +135,9 @@ static int soc_i2c_wait_dev_ready(SOC_I2C_CONTROLLER controller_id,
     return I2C_TIMEOUT - ret;
 }
 
-int soc_i2c_openadapter(uint8_t address) {
-    int ret;
+int soc_i2c_openadapter(uint32_t address, int i2c_speed, int i2c_addr_mode)
+{
+    int ret = 0;
 
     // use I2C0
     SET_PIN_MODE(20, I2C_MUX_MODE);
@@ -138,8 +149,8 @@ int soc_i2c_openadapter(uint8_t address) {
     i2c_cfg_data_t i2c_cfg;
     memset(&i2c_cfg, 0, sizeof(i2c_cfg_data_t));
 
-    i2c_cfg.speed = I2C_FAST;
-    i2c_cfg.addressing_mode = I2C_7_Bit;
+    i2c_cfg.speed = i2c_speed;
+    i2c_cfg.addressing_mode = i2c_addr_mode;
     if (address) {
         i2c_cfg.mode_type = I2C_SLAVE;
         i2c_cfg.cb_tx = soc_i2c_slave_tx_callback;
@@ -159,35 +170,37 @@ int soc_i2c_openadapter(uint8_t address) {
 
     soc_i2c_set_config(SOC_I2C_0, &i2c_cfg);
     soc_i2c_clock_enable(SOC_I2C_0);
+
     ret = soc_i2c_wait_dev_ready(SOC_I2C_0, false);
-    if (i2c_cfg.mode_type == I2C_SLAVE)
-    {
-        soc_i2c_slave_enable(SOC_I2C_0);
-    }
 
     return ret;
 }
 
-void soc_i2c_setslave(uint8_t addr) {
-    soc_i2c_slave = addr;
+void soc_i2c_master_set_slave_address(uint32_t addr)
+{
+    soc_i2c_slave_address = addr;
     return;
 }
 
-void soc_i2c_slave_set_rx_user_buffer(uint8_t *buffer, uint8_t length) {
+void soc_i2c_slave_set_rx_user_buffer(uint8_t *buffer, uint8_t length)
+{
     soc_i2c_slave_enable_rx(SOC_I2C_0, buffer, length);
 }
 
-void soc_i2c_slave_set_tx_user_buffer(uint8_t *buffer, uint8_t length) {
+void soc_i2c_slave_set_tx_user_buffer(uint8_t *buffer, uint8_t length)
+{
     soc_i2c_slave_enable_tx(SOC_I2C_0, buffer, length);
 }
 
-int soc_i2c_master_witebytes(uint8_t *bytes, uint8_t length, bool no_stop) {
+int soc_i2c_master_witebytes(uint8_t *bytes, uint8_t length, bool no_stop)
+{
     int ret;
 
     soc_i2c_master_tx_complete = 0;
     soc_i2c_err_detect = 0;
     soc_i2c_err_source = 0;
-    soc_i2c_transfer(SOC_I2C_0, bytes, length, 0, 0, soc_i2c_slave, no_stop);
+    soc_i2c_master_transfer(SOC_I2C_0, bytes, length, 0, 0,
+                            soc_i2c_slave_address, no_stop);
     ret = soc_i2c_master_wait_tx_or_err();
     if (ret)
         return ret;
@@ -197,13 +210,15 @@ int soc_i2c_master_witebytes(uint8_t *bytes, uint8_t length, bool no_stop) {
     return length;
 }
 
-int soc_i2c_master_readbytes(uint8_t *buf, int length, bool no_stop) {
+int soc_i2c_master_readbytes(uint8_t *buf, int length, bool no_stop)
+{
     int ret;
 
     soc_i2c_master_rx_complete = 0;
     soc_i2c_err_detect = 0;
     soc_i2c_err_source = 0;
-    soc_i2c_transfer(SOC_I2C_0, buf, length, 0, 0, soc_i2c_slave, no_stop);
+    soc_i2c_master_transfer(SOC_I2C_0, 0, 0, buf, length, soc_i2c_slave_address,
+                            no_stop);
     ret = soc_i2c_master_wait_rx_or_err();
     if (ret)
         return ret;

libraries/Wire2/examples/master_check/master_check.ino

@@ -0,0 +1,102 @@
+// Wire2 Master Wiret/Reader test Sketch
+// by Nicholas Zambetti <http://www.zambetti.com>
+
+// Demonstrates use of the Wire2 library
+// Reads data from an I2C/TWI slave device
+// Writes data to an I2C/TWI slave device
+// Refer to the "Wire2 Slave Sender/Receiver" example for use with this
+
+// Created 29 March 2006
+
+// This example code is in the public domain.
+
+/**
+ * the sent data(8 bits): the higher 4 bits are equal to count and count will increase by 1 in every loop
+ * when master is as writer, data are got from buffer_sender
+ * when master is as reader, the received data are stored in buffer_receiver
+ * data checking is to verify whether the buffer_sender is equal to buffer_receiver 
+ **/
+#include <Wire2.h>
+
+#define BUFFER_SIZE 32
+
+static int count = 0;  // recode the higher 4 bits of data
+static uint8_t buffer_sender[BUFFER_SIZE]; // data source for master writer
+static uint8_t buffer_receiver[BUFFER_SIZE]; // data distination for master reader
+
+void setup() 
+{
+  Wire2.begin();         // join i2c bus (address optional for master)
+  Serial.begin(115200); // start serial for output
+  while (Serial)
+    ;
+}
+
+void loop() 
+{
+  int ret = 0;
+  int  bytesWritten = 0;
+
+  count++;
+
+  Wire2.beginTransmission(8); // transmit to device #8
+
+  for (int i = 0; i < BUFFER_SIZE; i++) 
+  {
+    buffer_sender[i] = i;
+  }
+  bytesWritten = Wire2.write(buffer_sender, BUFFER_SIZE); 
+
+  ret = Wire2.endTransmission();    // stop transmitting
+  if (ret != 0)
+  {
+      Serial.print("master write failed with error ");
+      Serial.println(ret);
+  }
+  else
+  {
+      Serial.print("master sucessfull write ");
+      Serial.print(bytesWritten);
+      Serial.println(" bytes");
+  }
+
+  ret = Wire2.requestFrom(8, bytesWritten, true);    // request BUFFER_SIZE bytes from slave device #8    
+  if (ret == 0)
+  {
+      Serial.println("master read failed");
+  }
+  else
+  {
+      Serial.print("master sucessfull read ");
+      Serial.print(ret);
+      Serial.println(" bytes");
+  }
+
+  int k = 0;
+  while (Wire2.available())   // slave may send less than requested
+  {
+    buffer_receiver[k] = Wire2.read();
+    k++;
+  }
+
+  // check data: the received data should be equal to the sent data 
+  for(int i = 0; i < bytesWritten; i++)
+  {
+    if(buffer_sender[i] == buffer_receiver[i])
+    {
+      /*Serial.println("OK");*/
+    }
+    else
+    {
+      Serial.print(buffer_sender[i],HEX);
+      Serial.print("  !=  ");
+      Serial.println(buffer_receiver[i],HEX);     
+    }    
+  }
+  
+  Serial.print("+++++");
+  Serial.print(count);
+  Serial.println("+++++");
+  delay(1000);  
+
+}

libraries/Wire2/examples/master_reader/master_reader.ino

@@ -0,0 +1,38 @@
+// Wire Master Reader
+// by Nicholas Zambetti <http://www.zambetti.com>
+
+// Demonstrates use of the Wire library
+// Reads data from an I2C/TWI slave device
+// Refer to the "Wire Slave Sender" example for use with this
+
+// Created 29 March 2006
+
+// This example code is in the public domain.
+
+
+#include <Wire2.h>
+
+void setup()
+{
+  Serial.begin(115200);  // start serial for output
+  while(Serial);
+
+  Wire2.begin();        // join i2c bus (address optional for master)
+}
+
+void loop()
+{
+
+  int ret = Wire2.requestFrom(8, 20, 1);    // request 20 bytes from slave device #8
+  if (ret == 0)
+  {
+    Serial.println("read from slave device failed");   
+  }
+    
+  while (Wire2.available())   // slave may send less than requested
+  {
+    char c = Wire2.read(); // receive a byte as character
+    Serial.println(c, HEX);
+  }
+  delay(1000);
+}

libraries/Wire2/examples/master_writer/master_writer.ino

@@ -0,0 +1,42 @@
+// Wire Master Writer
+// by Nicholas Zambetti <http://www.zambetti.com>
+
+// Demonstrates use of the Wire library
+// Writes data to an I2C/TWI slave device
+// Refer to the "Wire Slave Receiver" example for use with this
+
+// Created 29 March 2006
+
+// This example code is in the public domain.
+
+
+#include <Wire2.h>
+
+void setup()
+{
+  Serial.begin(115200);
+  while(Serial);
+
+  Wire2.begin(); // join i2c bus (address optional for master)
+}
+
+byte x = 1;
+byte rdata;
+void loop()
+{
+  Wire2.beginTransmission(8); // transmit to device #8
+  Wire2.write(x);              // sends one byte
+  int result = Wire2.endTransmission();    // stop transmitting
+  if (result == 0)
+  {
+    Serial.print("x =  ");
+    Serial.println(x);
+  }
+  else
+  {
+    Serial.print("transmit failed with error code ");
+    Serial.println(result);
+  }
+  x++;
+  delay(500);
+}