Added I2C slave echo example in examples folder. Using another maple, write a byte and then read.

Slight tidy up.
Reformatted CREDITS file to be in correct order.
Added a note about buffer overrun

Signed-off-by:- Barry Carter <barry.carter@gmail.com>

4 files changed, 121 insertions, 6 deletions

diff --git a/CREDITS b/CREDITS
index 5918e01..0fa915a 100644
--- a/CREDITS
+++ b/CREDITS
@@ -18,6 +18,11 @@ E: mbolivar@leaflabs.com
 D: Current libmaple maintainer
 D: Random libmaple hacks
 
+N: Barry Carter ("ginge")
+E: barry.carter@gmail.com
+D: Added I2C slave support
+W: headfuzz.co.uk
+
 N: Anton Eltchaninov
 E: anton.eltchaninov@gmail.com
 D: STM32F1 value line support
@@ -81,9 +86,4 @@ W: http://sarup.dk/index.html
 N: Andy Scott ("xttocs")
 E: andy.g.scott@gmail.com
 D: LiquidCrystal library
-
-N: Barry Carter ("ginge")
-E: barry.carter@gmail.com
-D: Added i2C slave support
-W: headfuzz.co.uk
- 
\ No newline at end of file
+ 
diff --git a/examples/i2c_slave_example.cpp b/examples/i2c_slave_example.cpp
new file mode 100644
index 0000000..98da58c
--- /dev/null
+++ b/examples/i2c_slave_example.cpp
@@ -0,0 +1,110 @@
+/*
+ * i2c_slave example.cpp
+ *
+ *  Created on: 4 Sep 2012
+ *      Author: Barry Carter <barry.carter@gmail.com>
+ */
+#include <wirish/wirish.h>
+#include <i2c.h>
+
+#define USE_BUFFERED_EXAMPLE 1
+
+i2c_msg msg;
+i2c_msg *pmsg = &msg;
+uint8 buffer[255];
+
+uint8 value_to_print = 'A';
+
+void funcrx(i2c_msg *msg)
+{
+    // Received length will be in msg->length
+    char return_data = msg->data[0];
+    value_to_print = return_data;
+}
+
+#if USE_BUFFERED_EXAMPLE == 1
+/* We ARE using a buffer to transmit the data out.
+ * Make sure you fill the buffer with the data AND you set the length correctly
+ */
+void functx(i2c_msg *msg)
+{
+    // Cheeky. We are using the received byte of the data which is currently in
+    // byte 0 to echo it back to the master device
+    //msg->data[0] = 0x01;    // We are re-using the rx buffer here to echo the request back
+    msg->data[1] = 0x02;
+    msg->data[2] = 0x03;
+    msg->data[3] = 0x04;
+    msg->data[4] = 0x05;
+    msg->length = 5;
+}
+
+#else
+
+/* We are NOT using the buffered data transmission
+ * We will get this callback for each outgoing packet. Make sure to call i2c_write
+ * Strickly speaking, we should be sending a NACk on the last byte we want to send
+ * but for this test example I am going to assume the master will NACK it when it
+ * wants to stop.
+ */
+void functx(i2c_msg *msg)
+{
+    i2c_write(I2C1, msg->data[0]);
+}
+
+#endif
+
+
+void setup() {
+    SerialUSB.begin();
+    SerialUSB.println("I2C Slave example");
+
+    // attach the buffer
+    msg.data = buffer;
+
+    /* Init slave mode. Enables master too
+     * We are going to configure the slave device to
+     *  - enable fast I2C (400khz)
+     *  - dual addresses (can have 2 addresses per module)
+     * general call (accepts data writes to 0x00 on a broadcast basis)
+     *
+     * If the buffered example is enabled, then we also enable the
+     * buffer for rx and tx.
+     * Note you can independently enable/disable RX and TX buffers to
+     * allow a buffered read and direct writes. Useful if you don't know how
+     * much the master will read.
+     */
+#if USE_BUFFERED_EXAMPLE == 1
+    i2c_slave_enable(I2C1, I2C_FAST_MODE | I2C_SLAVE_DUAL_ADDRESS | I2C_SLAVE_GENERAL_CALL | I2C_SLAVE_USE_RX_BUFFER | I2C_SLAVE_USE_TX_BUFFER);
+#else
+    i2c_slave_enable(I2C1, I2C_FAST_MODE | I2C_SLAVE_DUAL_ADDRESS | I2C_SLAVE_GENERAL_CALL);
+#endif
+
+    // attach  receive handler
+    i2c_slave_attach_recv_handler(I2C1, &msg, funcrx);
+    // attach transmit handler
+    i2c_slave_attach_transmit_handler(I2C1, &msg, functx);
+
+    // set addresss 1 to 16
+    i2c_slave_set_own_address(I2C1, 0x10);
+    // set addresss 2 to 32
+    i2c_slave_set_own_address2(I2C1, 0x20);
+}
+
+void loop() {
+    SerialUSB.print("Last byte: ");
+    SerialUSB.println(value_to_print);
+}
+
+// Force init() to be called before anything else.
+__attribute__((constructor)) void premain() {
+    init();
+}
+
+int main(void) {
+    setup();
+
+    while (true) {
+        loop();
+    }
+    return 0;
+}
diff --git a/libmaple/i2c.c b/libmaple/i2c.c
index 6c609d9..bbbf123 100644
--- a/libmaple/i2c.c
+++ b/libmaple/i2c.c
@@ -458,6 +458,10 @@ void _i2c_irq_handler(i2c_dev *dev) {
         if (sr1 & I2C_SR1_RXNE) {
             if (dev->config_flags & I2C_SLAVE_USE_RX_BUFFER) {
                 /* Fill the buffer with the contents of the data register */
+                /* These is potential for buffer overflow here, so we should
+                 * really store the size of the array. This is expensive in
+                 * the ISR so left out for now. We must trust the implementor!
+                 */
                 dev->i2c_slave_msg->data[dev->i2c_slave_msg->xferred++] = dev->regs->DR;
                 dev->i2c_slave_msg->length++;
             }
diff --git a/libmaple/include/libmaple/i2c.h b/libmaple/include/libmaple/i2c.h
index 5a9da58..fbb4c09 100644
--- a/libmaple/include/libmaple/i2c.h
+++ b/libmaple/include/libmaple/i2c.h
@@ -210,6 +210,7 @@ typedef struct i2c_msg {
 #define I2C_SLAVE_DUAL_ADDRESS  0x40          // Enable the dual slave address scheme
 #define I2C_SLAVE_GENERAL_CALL  0x80          // Enable the general call on address 0x00
 void i2c_master_enable(i2c_dev *dev, uint32 flags);
+void i2c_slave_enable(i2c_dev *dev, uint32 flags);
 
 #define I2C_ERROR_PROTOCOL      (-1)
 #define I2C_ERROR_TIMEOUT       (-2)