1 files changed, 1 insertions, 234 deletions

diff --git a/libmaple/i2c.c b/libmaple/i2c.c
index b8e622d..9c93d3f 100644
--- a/libmaple/i2c.c
+++ b/libmaple/i2c.c
@@ -154,7 +154,6 @@ void i2c_bus_reset(const i2c_dev *dev) {
 void i2c_init(i2c_dev *dev) {
     rcc_reset_dev(dev->clk_id);
     rcc_clk_enable(dev->clk_id);
-    _i2c_irq_priority_fixup(dev);
 }
 
 /* Hack for deprecated bit of STM32F1 functionality */
@@ -199,30 +198,12 @@ void i2c_master_enable(i2c_dev *dev, uint32 flags) {
     nvic_irq_enable(dev->er_nvic_line);
     i2c_enable_irq(dev, I2C_IRQ_EVENT | I2C_IRQ_BUFFER | I2C_IRQ_ERROR);
 
-    /* Configure the slave unit */
-    if (flags & I2C_SLAVE_DUAL_ADDRESS) {
-        i2c_slave_dual_address_enable(dev);
-    }
-
-    if (flags & I2C_SLAVE_GENERAL_CALL) {
-        i2c_slave_general_call_enable(dev);
-    }
-
-    /* store all of the flags */
-    dev->config_flags = flags;
-
     /* Make it go! */
     i2c_peripheral_enable(dev);
-    i2c_enable_ack(dev);
 
     dev->state = I2C_STATE_IDLE;
 }
 
-void i2c_slave_enable(i2c_dev *dev, uint32 flags) {
-    i2c_disable(dev);
-    i2c_master_enable(dev, dev->config_flags | flags);
-}
-
 /**
  * @brief Process an i2c transaction.
  *
@@ -322,152 +303,6 @@ void _i2c_irq_handler(i2c_dev *dev) {
      */
     dev->timestamp = systick_uptime();
 
-    /* Add Slave support
-     * Barry Carter 2012
-     * barry.carter@gmail.com
-     */
-    
-    /* Check to see if MSL master slave bit is set */
-    if ((sr2 & I2C_SR2_MSL) != I2C_SR2_MSL) { /* 0 = slave mode 1 = master */
-
-        /* Check for address match */
-        if (sr1 & I2C_SR1_ADDR) {
-            /* Find out which address was matched */
-            /* Check the general call address first */
-            if (sr2 & I2C_SR2_GENCALL) {
-                dev->i2c_slave_msg->addr = 0;
-            }
-            /* We matched the secondary address */
-            else if (sr2 & I2C_SR2_DUALF) {
-                dev->i2c_slave_msg->addr = dev->regs->OAR2 & 0xFE;
-            }
-            /* We matched the primary address */
-            else if ((sr2 & I2C_SR2_DUALF) != I2C_SR2_DUALF) {
-                dev->i2c_slave_msg->addr = dev->regs->OAR1 & 0xFE;
-            }
-            /* Shouldn't get here */
-            else {
-                dev->i2c_slave_msg->addr = -1; /* uh oh */
-            }
-
-            /* if we have buffered io */
-            if ((dev->config_flags & I2C_SLAVE_USE_RX_BUFFER) ||
-                (dev->config_flags & I2C_SLAVE_USE_TX_BUFFER)) {
-
-                /* if receiving then this would be a repeated start
-                 *
-                 *if we have some bytes already
-                 */
-                if ((dev->state == I2C_STATE_SL_RX) &&
-                    (dev->i2c_slave_msg->xferred > 0)  &&
-                    (dev->config_flags & I2C_SLAVE_USE_RX_BUFFER)) {
-                    /* Call the callback with the contents of the data */
-                    if (dev->i2c_slave_recv_callback != NULL) {
-                        (*(dev->i2c_slave_recv_callback))(dev->i2c_slave_msg);
-                    }
-                }
-
-                /* Reset the message back to defaults.
-                 * We are starting a new message
-                 */
-                dev->i2c_slave_msg->flags = 0;
-                dev->i2c_slave_msg->length = 0;
-                dev->i2c_slave_msg->xferred = 0;
-                dev->msgs_left = 0;
-                dev->timestamp = systick_uptime();
-
-                /* We have been addressed with SLA+R so
-                 * the master wants us to transmit
-                 */
-                if ((sr1 & I2C_SR1_TXE) &&
-                    (dev->config_flags & I2C_SLAVE_USE_TX_BUFFER)) {
-                    /* Call the transmit callback so it can populate the msg
-                     * data with the bytes to go
-                     */
-                    if (dev->i2c_slave_transmit_callback != NULL) {
-                        (*(dev->i2c_slave_transmit_callback))(dev->i2c_slave_msg);
-                    }
-                }
-                dev->state = I2C_STATE_BUSY;
-            }
-
-            sr1 = sr2 = 0;
-        }
-        
-         /* EV3: Master requesting data from slave. Transmit a byte*/
-        if (sr1 & I2C_SR1_TXE) {
-            if (dev->config_flags & I2C_SLAVE_USE_TX_BUFFER) {
-                if (dev->i2c_slave_msg->xferred >= dev->i2c_slave_msg->length) {
-                    /* End of the transmit buffer? If so we NACK */
-                    i2c_disable_ack(dev);
-                    /* We have to either issue a STOP or write something here.
-                     * STOP here seems to screw up some masters,
-                     * For now padding with 0
-                     */
-                    i2c_write(dev, 0);
-                    /*i2c_stop_condition(dev); // This is causing bus lockups way more than it should !? Seems some I2C master devices freak out here*/
-                }
-                else
-                {
-                    /* NACk the last byte */
-                    if (dev->i2c_slave_msg->xferred == dev->i2c_slave_msg->length-1) {
-                        i2c_disable_ack(dev);
-                    }
-                    else {
-                        i2c_enable_ack(dev);
-                    }
-                    i2c_write(dev, dev->i2c_slave_msg->data[dev->i2c_slave_msg->xferred++]);
-                }
-            }
-            else
-            {
-                /* Call the callback to get the data we need.
-                 * The callback is expected to write using i2c_write(...)
-                 * If the slave is going to terminate the transfer, this function should
-                 * also do a NACK on the last byte!
-                 */
-                if (dev->i2c_slave_transmit_callback != NULL) (*(dev->i2c_slave_transmit_callback))(dev->i2c_slave_msg);
-            }
-
-            dev->state = I2C_STATE_BUSY;
-            sr1 = sr2 = 0;
-        }
-        
-        /* EV2: Slave received data from a master. Get from DR */
-        if (sr1 & I2C_SR1_RXNE) {
-            if (dev->config_flags & I2C_SLAVE_USE_RX_BUFFER) {
-                /* Fill the buffer with the contents of the data register */
-                dev->i2c_slave_msg->data[dev->i2c_slave_msg->xferred++] = dev->regs->DR;
-                dev->i2c_slave_msg->length++;
-            }
-            else  {
-                /* Call the callback with the contents of the data */
-                dev->i2c_slave_msg->data[0] = dev->regs->DR;
-                if (dev->i2c_slave_recv_callback != NULL) (*(dev->i2c_slave_recv_callback))(dev->i2c_slave_msg);
-            }
-            dev->state = I2C_STATE_SL_RX;
-            sr1 = sr2 = 0;
-        }
-
-        /* EV4: Slave has detected a STOP condition on the bus */
-        if (sr1 & I2C_SR1_STOPF) {
-            dev->regs->CR1 |= I2C_CR1_PE;
-
-            if ((dev->config_flags & I2C_SLAVE_USE_RX_BUFFER) ||
-                (dev->config_flags & I2C_SLAVE_USE_TX_BUFFER)) {
-
-                /* The callback with the data will happen on a NACK of the last data byte.
-                 * This is handled in the error IRQ (AF bit)
-                 */
-            }
-
-            sr1 = sr2 = 0;
-            dev->state = I2C_STATE_IDLE;
-        }
-
-        return;
-    }
-    
     /*
      * EV5: Start condition sent
      */
@@ -612,7 +447,6 @@ void _i2c_irq_handler(i2c_dev *dev) {
             }
         }
     }
-
 }
 
 /*
@@ -622,49 +456,10 @@ void _i2c_irq_handler(i2c_dev *dev) {
 void _i2c_irq_error_handler(i2c_dev *dev) {
     I2C_CRUMB(ERROR_ENTRY, dev->regs->SR1, dev->regs->SR2);
 
-    dev->error_flags = dev->regs->SR1 & (I2C_SR1_BERR |
+    dev->error_flags = dev->regs->SR2 & (I2C_SR1_BERR |
                                          I2C_SR1_ARLO |
                                          I2C_SR1_AF |
                                          I2C_SR1_OVR);
-
-    /* Are we in slave mode? */
-    if ((dev->regs->SR2 & I2C_SR2_MSL) != I2C_SR2_MSL) {
-        /* Check to see if the master device did a NAK on the last bit
-         * This is perfectly valid for a master to do this on the bus.
-         * We ignore this. Any further error processing takes us into dead
-         * loop waiting for the stop condition that will never arrive
-         */
-        if (dev->regs->SR1 & I2C_SR1_AF) {
-            /* Clear flags */
-            dev->regs->SR1 = 0;
-            dev->regs->SR2 = 0;
-            /* We need to write something to CR1 to clear the flag.
-             * This isn't really mentioned but seems important */
-            i2c_enable_ack(dev);
-
-            if (dev->state == I2C_STATE_SL_RX &&
-                dev->config_flags & I2C_SLAVE_USE_RX_BUFFER &&
-                dev->i2c_slave_msg->xferred > 0) {
-                /* Call the callback with the contents of the data */
-                if (dev->i2c_slave_recv_callback != NULL) (*(dev->i2c_slave_recv_callback))(dev->i2c_slave_msg);
-            }
-
-            dev->state = I2C_STATE_IDLE;
-            return;
-        }
-        /* Catch any other strange errors while in slave mode.
-         * I have seen BERR caused by an over fast master device
-         * as well as several overflows and arbitration failures.
-         * We are going to reset SR flags and carry on at this point which
-         * is not the best thing to do, but stops the bus locking up completely
-         * If we carry on below and send the stop bit, the code spins forever */
-        /* Clear flags */
-        dev->regs->SR1 = 0;
-        dev->regs->SR2 = 0;
-        dev->state = I2C_STATE_IDLE;
-        return;
-    }
-
     /* Clear flags */
     dev->regs->SR1 = 0;
     dev->regs->SR2 = 0;
@@ -712,31 +507,3 @@ static void set_ccr_trise(i2c_dev *dev, uint32 flags) {
     i2c_set_clk_control(dev, ccr);
     i2c_set_trise(dev, trise);
 }
-
-
-/**
- * @brief callback for when the device acts as a slave. If using an rx buffer, this is triggered
- * after the last byte, otherwise it is called for every incoming packet.
- * @param dev I2C device
- * @param msg The dev_msg to pass to the slave init code
- * @param func The function pointer to call
- */
-void i2c_slave_attach_recv_handler(i2c_dev *dev, i2c_msg *msg, i2c_slave_recv_callback_func func) {
-    dev->i2c_slave_recv_callback = func;
-    dev->i2c_slave_msg = msg;
-    msg->xferred = 0;
-}
-
-
-/**
- * @brief callback for when the device acts as a slave. If using a tx buffer, this is triggered
- * after the device is successsfully addressed with SLA+R.
- * @param dev I2C device
- * @param msg The dev_msg to pass to the slave init code
- * @param func The function pointer to call
- */
-void i2c_slave_attach_transmit_handler(i2c_dev *dev, i2c_msg *msg, i2c_slave_transmit_callback_func func) {
-    dev->i2c_slave_transmit_callback = func;
-    dev->i2c_slave_msg = msg;
-    msg->xferred = 0;
-}