View difference between Paste ID: 9mk2bssk and cjza1CnD

 diff --git a/libmaple/i2c.c b/libmaple/i2c.c
-index 9c93d3f..4902ec3 100644
+index 9c93d3f..b8e622d 100644
 --- a/libmaple/i2c.c
 +++ b/libmaple/i2c.c
 @@ -154,6 +154,7 @@ 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 */
 @@ -198,12 +199,30 @@ 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);
++        i2c_slave_dual_address_enable(dev);
-+	}
+
 +
-+	if (flags & I2C_SLAVE_GENERAL_CALL) {
++    if (flags & I2C_SLAVE_GENERAL_CALL) {
-+		i2c_slave_general_call_enable(dev);
++        i2c_slave_general_call_enable(dev);
-+	}
+
 +
-+	/* store all of the flags */
++    /* store all of the flags */
-+	dev->config_flags = 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_disable(dev);
-+	i2c_master_enable(dev, dev->config_flags | flags);
++    i2c_master_enable(dev, dev->config_flags | flags);
 +}
 +
  /**
   * @brief Process an i2c transaction.
   *
-@@ -303,150 +322,296 @@ void _i2c_irq_handler(i2c_dev *dev) {
+@@ -303,6 +322,152 @@ void _i2c_irq_handler(i2c_dev *dev) {
       */
      dev->timestamp = systick_uptime();
 
--    /*
+
--     * EV5: Start condition sent
+
 +     * [email protected]
 +     */
 +
 +    /* Check to see if MSL master slave bit is set */
--    if (sr1 & I2C_SR1_SB) {
+
--        msg->xferred = 0;
+
--        i2c_enable_irq(dev, I2C_IRQ_BUFFER);
+
--
+
--        /*
++            /* Find out which address was matched */
--         * Master receiver
++            /* Check the general call address first */
--         */
++            if (sr2 & I2C_SR2_GENCALL) {
--        if (read) {
++                dev->i2c_slave_msg->addr = 0;
--            i2c_enable_ack(dev);
++            }
 +            /* We matched the secondary address */
 +            else if (sr2 & I2C_SR2_DUALF) {
 +                dev->i2c_slave_msg->addr = dev->regs->OAR2 & 0xFE;
 +            }
-+    	dev->state = I2C_STATE_BUSY;
++            /* We matched the primary address */
 +            else if ((sr2 & I2C_SR2_DUALF) != I2C_SR2_DUALF) {
 +                dev->i2c_slave_msg->addr = dev->regs->OAR1 & 0xFE;
 +            }
-+        	/* Find out which address was matched */
++            /* Shouldn't get here */
-+        	/* Check the general call address first */
++            else {
-+        	if (sr2 & I2C_SR2_GENCALL) {
++                dev->i2c_slave_msg->addr = -1; /* uh oh */
-+        		dev->i2c_slave_msg->addr = 0;
++            }
-+        	}
+
-+        	/* We matched the secondary address */
++            /* if we have buffered io */
-+        	else if (sr2 & I2C_SR2_DUALF) {
+
-+        		dev->i2c_slave_msg->addr = dev->regs->OAR2 & 0xFE;
++                (dev->config_flags & I2C_SLAVE_USE_TX_BUFFER)) {
-+        	}
+
-+        	/* We matched the primary address */
++                /* if receiving then this would be a repeated start
-+        	else if ((sr2 & I2C_SR2_DUALF) != I2C_SR2_DUALF) {
++                 *
-+        		dev->i2c_slave_msg->addr = dev->regs->OAR1 & 0xFE;
++                 *if we have some bytes already
-+        	}
++                 */
-+        	/* Shouldn't get here */
++                if ((dev->state == I2C_STATE_SL_RX) &&
-+        	else {
++                    (dev->i2c_slave_msg->xferred > 0)  &&
-+        		dev->i2c_slave_msg->addr = -1; /* uh oh */
++                    (dev->config_flags & I2C_SLAVE_USE_RX_BUFFER)) {
-+        	}
++                    /* Call the callback with the contents of the data */
 +                    if (dev->i2c_slave_recv_callback != NULL) {
-+        	/* if we have buffered io */
++                        (*(dev->i2c_slave_recv_callback))(dev->i2c_slave_msg);
-+        	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
++                /* Reset the message back to defaults.
-+        		 *
++                 * We are starting a new message
-+        		 *if we have some bytes already
++                 */
-+        		 */
++                dev->i2c_slave_msg->flags = 0;
-+				if (((sr1 & I2C_SR1_TXE) != I2C_SR1_TXE) &&
++                dev->i2c_slave_msg->length = 0;
-+					(dev->i2c_slave_msg->xferred > 0)  &&
++                dev->i2c_slave_msg->xferred = 0;
-+					(dev->config_flags & I2C_SLAVE_USE_RX_BUFFER)) {
++                dev->msgs_left = 0;
-+					/* Call the callback with the contents of the data */
++                dev->timestamp = systick_uptime();
-+					if (dev->i2c_slave_recv_callback != NULL) {
+
-+						(*(dev->i2c_slave_recv_callback))(dev->i2c_slave_msg);
++                /* We have been addressed with SLA+R so
-+					}
++                 * the master wants us to transmit
-+				}
++                 */
 +                if ((sr1 & I2C_SR1_TXE) &&
-+				/* Reset the message back to defaults.
++                    (dev->config_flags & I2C_SLAVE_USE_TX_BUFFER)) {
-+				 * We are starting a new message
++                    /* Call the transmit callback so it can populate the msg
-+				 */
++                     * data with the bytes to go
-+				dev->i2c_slave_msg->flags = 0;
++                     */
-+				dev->i2c_slave_msg->length = 0;
++                    if (dev->i2c_slave_transmit_callback != NULL) {
-+				dev->i2c_slave_msg->xferred = 0;
++                        (*(dev->i2c_slave_transmit_callback))(dev->i2c_slave_msg);
-+				dev->msgs_left = 0;
++                    }
-+				dev->timestamp = systick_uptime();
++                }
 +                dev->state = I2C_STATE_BUSY;
-+				/* 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->config_flags & I2C_SLAVE_USE_TX_BUFFER) {
-+        	    	if (dev->i2c_slave_transmit_callback != NULL) {
++                if (dev->i2c_slave_msg->xferred >= dev->i2c_slave_msg->length) {
-+        	    		(*(dev->i2c_slave_transmit_callback))(dev->i2c_slave_msg);
++                    /* 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
-+        	if (dev->config_flags & I2C_SLAVE_USE_TX_BUFFER) {
++                {
-+        		if (dev->i2c_slave_msg->xferred >= dev->i2c_slave_msg->length) {
++                    /* NACk the last byte */
-+        			/* End of the transmit buffer? If so we NACK */
++                    if (dev->i2c_slave_msg->xferred == dev->i2c_slave_msg->length-1) {
-+        			i2c_disable_ack(dev);
++                        i2c_disable_ack(dev);
-+        			/* We have to either issue a STOP or write something here.
++                    }
-+        			 * STOP here seems to screw up some masters,
++                    else {
-+					 * For now padding with 0
++                        i2c_enable_ack(dev);
-+        			 */
++                    }
-+        			i2c_write(dev, 0);
++                    i2c_write(dev, dev->i2c_slave_msg->data[dev->i2c_slave_msg->xferred++]);
-+        			/*i2c_stop_condition(dev); // This is causing bus lockups way more than it should !? Seems some I2C master devices freak out here*/
++                }
-+        		}
++            }
-+        		else
++            else
-+        		{
++            {
-+        			/* NACk the last byte */
++                /* Call the callback to get the data we need.
-+					if (dev->i2c_slave_msg->xferred == dev->i2c_slave_msg->length-1) {
++                 * The callback is expected to write using i2c_write(...)
-+						i2c_disable_ack(dev);
++                 * If the slave is going to terminate the transfer, this function should
-+					}
++                 * also do a NACK on the last byte!
-+					else {
++                 */
-+						i2c_enable_ack(dev);
++                if (dev->i2c_slave_transmit_callback != NULL) (*(dev->i2c_slave_transmit_callback))(dev->i2c_slave_msg);
-+					}
++            }
-+					i2c_write(dev, dev->i2c_slave_msg->data[dev->i2c_slave_msg->xferred++]);
+
-+        		}
++            dev->state = I2C_STATE_BUSY;
-+        	}
+
-+        	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
++            if (dev->config_flags & I2C_SLAVE_USE_RX_BUFFER) {
-+				 * also do a NACK on the last byte!
++                /* Fill the buffer with the contents of the data register */
-+				 */
++                dev->i2c_slave_msg->data[dev->i2c_slave_msg->xferred++] = dev->regs->DR;
-+				if (dev->i2c_slave_transmit_callback != NULL) (*(dev->i2c_slave_transmit_callback))(dev->i2c_slave_msg);
++                dev->i2c_slave_msg->length++;
-+        	}
++            }
 +            else  {
-+        	sr1 = sr2 = 0;
++                /* 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;
-+        	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->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)
 +                 */
--        i2c_send_slave_addr(dev, msg->addr, read);
++            }
--        sr1 = sr2 = 0;
+
--    }
+
 +            dev->state = I2C_STATE_IDLE;
 +        }
 +
 +        return;
--    /*
+
--     * EV6: Slave address sent
+
--     */
+     /*
--    if (sr1 & I2C_SR1_ADDR) {
+      * EV5: Start condition sent
--        /*
+
--         * Special case event EV6_1 for master receiver.
+@@ -447,6 +612,7 @@ void _i2c_irq_handler(i2c_dev *dev) {
--         * Generate NACK and restart/stop condition after ADDR
+             }
--         * is cleared.
+
--         */
+
--        if (read) {
+
--            if (msg->length == 1) {
+
--                i2c_disable_ack(dev);
+
--                if (dev->msgs_left > 1) {
+
--                    i2c_start_condition(dev);
+@@ -456,10 +622,49 @@ void _i2c_irq_handler(i2c_dev *dev) {
--                    I2C_CRUMB(RX_ADDR_START, 0, 0);
+
--                } else {
+
--                    i2c_stop_condition(dev);
+
--                    I2C_CRUMB(RX_ADDR_STOP, 0, 0);
+
--                }
+
--            }
+
--        } else {
+
--            /*
+
--             * Master transmitter: write first byte to fill shift
+
--             * register.  We should get another TXE interrupt
+
--             * immediately to fill DR again.
+
--             */
++        /* Check to see if the master device did a NAK on the last bit
--            if (msg->length != 1) {
++         * This is perfectly valid for a master to do this on the bus.
--                i2c_write(dev, msg->data[msg->xferred++]);
++         * We ignore this. Any further error processing takes us into dead
--            }
++         * loop waiting for the stop condition that will never arrive
--        }
++         */
--        sr1 = sr2 = 0;
++        if (dev->regs->SR1 & I2C_SR1_AF) {
--    }
++            /* Clear flags */
 +            dev->regs->SR1 = 0;
-+            	(dev->config_flags & I2C_SLAVE_USE_TX_BUFFER)) {
++            dev->regs->SR2 = 0;
 +            /* We need to write something to CR1 to clear the flag.
--    /*
++             * This isn't really mentioned but seems important */
--     * EV8: Master transmitter
++            i2c_enable_ack(dev);
--     * Transmit buffer empty, but we haven't finished transmitting the last
+
--     * byte written.
++            if (dev->state == I2C_STATE_SL_RX &&
--     */
++                dev->config_flags & I2C_SLAVE_USE_RX_BUFFER &&
--    if ((sr1 & I2C_SR1_TXE) && !(sr1 & I2C_SR1_BTF)) {
++                dev->i2c_slave_msg->xferred > 0) {
--        I2C_CRUMB(TXE_ONLY, 0, 0);
++                /* Call the callback with the contents of the data */
--        if (dev->msgs_left) {
++                if (dev->i2c_slave_recv_callback != NULL) (*(dev->i2c_slave_recv_callback))(dev->i2c_slave_msg);
--            i2c_write(dev, msg->data[msg->xferred++]);
++            }
--            if (msg->xferred == msg->length) {
+
--                /*
+
--                 * End of this message. Turn off TXE/RXNE and wait for
++            return;
--                 * BTF to send repeated start or stop condition.
+
--                 */
++        /* Catch any other strange errors while in slave mode.
--                i2c_disable_irq(dev, I2C_IRQ_BUFFER);
++         * I have seen BERR caused by an over fast master device
--                dev->msgs_left--;
++         * as well as several overflows and arbitration failures.
--            }
++         * We are going to reset SR flags and carry on at this point which
--        } else {
++         * 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 */
--             * This should be impossible...
+
--             */
+
--            ASSERT(0);
+
--        }
+
--        sr1 = sr2 = 0;
+
--    }
+
-+        		/* The callback with the data will happen on a NACK of the last data byte.
+
-+        		 * This is handled in the error IRQ (AF bit)
+
-+        		 */
+
-+        	}
+
 @@ -507,3 +712,31 @@ static void set_ccr_trise(i2c_dev *dev, uint32 flags) {
--    /*
+
--     * EV8_2: Master transmitter
+
--     * Last byte sent, program repeated start/stop
+
--     */
+
--    if ((sr1 & I2C_SR1_TXE) && (sr1 & I2C_SR1_BTF)) {
+
--        I2C_CRUMB(TXE_BTF, 0, 0);
+
--        if (dev->msgs_left) {
+
--            I2C_CRUMB(TEST, 0, 0);
+
--            /*
+
--             * Repeated start insanity: We can't disable ITEVTEN or else SB
+
--             * won't interrupt, but if we don't disable ITEVTEN, BTF will
+
--             * continually interrupt us. What the fuck ST?
+
--             */
+
--            i2c_start_condition(dev);
+
--            while (!(dev->regs->SR1 & I2C_SR1_SB))
+
--                ;
+
--            dev->msg++;
+
--        } else {
+
--            i2c_stop_condition(dev);
+
--
+
--            /*
+
--             * Turn off event interrupts to keep BTF from firing until
+
--             * the end of the stop condition. Why on earth they didn't
+
--             * have a start/stop condition request clear BTF is beyond
+
--             * me.
+
--             */
+
--            i2c_disable_irq(dev, I2C_IRQ_EVENT);
+
--            I2C_CRUMB(STOP_SENT, 0, 0);
++    dev->i2c_slave_transmit_callback = func;
--            dev->state = I2C_STATE_XFER_DONE;
+
 +    msg->xferred = 0;
 +}
 diff --git a/libmaple/include/libmaple/i2c.h b/libmaple/include/libmaple/i2c.h
--        sr1 = sr2 = 0;
+
--    }
+
 +++ b/libmaple/include/libmaple/i2c.h
--    /*
+
--     * EV7: Master Receiver
+
--     */
+
--    if (sr1 & I2C_SR1_RXNE) {
+
--        I2C_CRUMB(RXNE_ONLY, 0, 0);
+
--        msg->data[msg->xferred++] = dev->regs->DR;
+
--
+
--        /*
+
--         * EV7_1: Second to last byte in the reception? Set NACK and generate
+
--         * stop/restart condition in time for the last byte. We'll get one more
+
--         * RXNE interrupt before shutting things down.
+
--         */
+
--        if (msg->xferred == (msg->length - 1)) {
+
--            i2c_disable_ack(dev);
+
--            if (dev->msgs_left > 2) {
+
--                i2c_start_condition(dev);
+
--                I2C_CRUMB(RXNE_START_SENT, 0, 0);
+
--            } else {
+
--                i2c_stop_condition(dev);
+
--                I2C_CRUMB(RXNE_STOP_SENT, 0, 0);
+
--            }
+
--        } else if (msg->xferred == msg->length) {
+
--            dev->msgs_left--;
+
--            if (dev->msgs_left == 0) {
+
--                /*
+
--                 * We're done.
+
--                 */
+
--                I2C_CRUMB(RXNE_DONE, 0, 0);
+
--                dev->state = I2C_STATE_XFER_DONE;
+
--            } else {
+
--                dev->msg++;
+
--            }
+
--        }
+
 +}
 +
 +/**
-+	/*
+
-+	 * EV5: Start condition sent
+
-+	 */
+
-+	if (sr1 & I2C_SR1_SB) {
+
-+		msg->xferred = 0;
+
-+		i2c_enable_irq(dev, I2C_IRQ_BUFFER);
+
 +
-+		/*
+
-+		 * Master receiver
+
-+		 */
+
-+		if (read) {
+
-+			i2c_enable_ack(dev);
+
-+		}
+
 + */
-+		i2c_send_slave_addr(dev, msg->addr, read);
+
-+		sr1 = sr2 = 0;
+
-+	}
+
 + * @brief Set the primary I2c slave address
-+	/*
+
-+	 * EV6: Slave address sent
+
-+	 */
+
-+	if (sr1 & I2C_SR1_ADDR) {
+
-+		/*
+
-+		 * Special case event EV6_1 for master receiver.
+
-+		 * Generate NACK and restart/stop condition after ADDR
+
-+		 * is cleared.
+
-+		 */
+
-+		if (read) {
+
-+			if (msg->length == 1) {
+
-+				i2c_disable_ack(dev);
+
-+				if (dev->msgs_left > 1) {
+
-+					i2c_start_condition(dev);
+
-+					I2C_CRUMB(RX_ADDR_START, 0, 0);
+
-+				} else {
+
-+					i2c_stop_condition(dev);
+
-+					I2C_CRUMB(RX_ADDR_STOP, 0, 0);
+
-+				}
+
-+			}
+
-+		} else {
+index 17cabe3..5debcb8 100644
-+			/*
+
-+			 * Master transmitter: write first byte to fill shift
+
-+			 * register.  We should get another TXE interrupt
+@@ -52,9 +52,12 @@ typedef enum i2c_state {
-+			 * immediately to fill DR again.
+     I2C_STATE_IDLE              = 1, /**< Idle */
-+			 */
+     I2C_STATE_XFER_DONE         = 2, /**< Done with transfer */
-+			if (msg->length != 1) {
+     I2C_STATE_BUSY              = 3, /**< Busy */
-+				i2c_write(dev, msg->data[msg->xferred++]);
++    I2C_STATE_SL_RX             = 4, /**< Slave receiving */
-+			}
+
-+		}
+
-+		sr1 = sr2 = 0;
+
-+	}
+
 +typedef void (*i2c_slave_transmit_callback_func)(struct i2c_msg *);
-+	/*
+
-+	 * EV8: Master transmitter
+
-+	 * Transmit buffer empty, but we haven't finished transmitting the last
+
-+	 * byte written.
+@@ -88,6 +91,17 @@ typedef struct i2c_dev {
-+	 */
+
-+	if ((sr1 & I2C_SR1_TXE) && !(sr1 & I2C_SR1_BTF)) {
+
-+		I2C_CRUMB(TXE_ONLY, 0, 0);
+
-+		if (dev->msgs_left) {
+
-+			i2c_write(dev, msg->data[msg->xferred++]);
+
-+			if (msg->xferred == msg->length) {
+
-+				/*
+
-+				 * End of this message. Turn off TXE/RXNE and wait for
+
-+				 * BTF to send repeated start or stop condition.
+
-+				 */
+
-+				i2c_disable_irq(dev, I2C_IRQ_BUFFER);
+
-+				dev->msgs_left--;
+
-+			}
+
-+		} else {
+
-+			/*
+
-+			 * This should be impossible...
+
-+			 */
+