Import prior SPI transaction work

SPI.cpp

@@ -8,61 +8,86 @@
  * published by the Free Software Foundation.
  */
 
-#include "pins_arduino.h"
 #include "SPI.h"
+#include "pins_arduino.h"
 
 SPIClass SPI;
 
-void SPIClass::begin() {
+uint8_t SPIClass::interruptMode = 0;
+uint8_t SPIClass::interruptMask = 0;
+uint8_t SPIClass::interruptSave = 0;
 
-  // Set SS to high so a connected chip will be "deselected" by default
-  digitalWrite(SS, HIGH);
+void SPIClass::begin()
+{
+	// Set SS to high so a connected chip will be "deselected" by default
+	digitalWrite(SS, HIGH);
 
-  // When the SS pin is set as OUTPUT, it can be used as
-  // a general purpose output port (it doesn't influence
-  // SPI operations).
-  pinMode(SS, OUTPUT);
+	// When the SS pin is set as OUTPUT, it can be used as
+	// a general purpose output port (it doesn't influence
+	// SPI operations).
+	pinMode(SS, OUTPUT);
 
-  // Warning: if the SS pin ever becomes a LOW INPUT then SPI
-  // automatically switches to Slave, so the data direction of
-  // the SS pin MUST be kept as OUTPUT.
-  SPCR |= _BV(MSTR);
-  SPCR |= _BV(SPE);
+	// Warning: if the SS pin ever becomes a LOW INPUT then SPI
+	// automatically switches to Slave, so the data direction of
+	// the SS pin MUST be kept as OUTPUT.
+	SPCR |= _BV(MSTR);
+	SPCR |= _BV(SPE);
 
-  // Set direction register for SCK and MOSI pin.
-  // MISO pin automatically overrides to INPUT.
-  // By doing this AFTER enabling SPI, we avoid accidentally
-  // clocking in a single bit since the lines go directly
-  // from "input" to SPI control.  
-  // http://code.google.com/p/arduino/issues/detail?id=888
+	// Set direction register for SCK and MOSI pin.
+	// MISO pin automatically overrides to INPUT.
+	// By doing this AFTER enabling SPI, we avoid accidentally
+	// clocking in a single bit since the lines go directly
+	// from "input" to SPI control.	 
+	// http://code.google.com/p/arduino/issues/detail?id=888
 #ifdef __AVR__
-  pinMode(SCK, OUTPUT);
-  pinMode(MOSI, OUTPUT);
+	pinMode(SCK, OUTPUT);
+	pinMode(MOSI, OUTPUT);
 #endif
 }
 
-
 void SPIClass::end() {
-  SPCR &= ~_BV(SPE);
+	SPCR &= ~_BV(SPE);
 }
 
-void SPIClass::setBitOrder(uint8_t bitOrder)
+void SPIClass::usingInterrupt(uint8_t interruptNumber)
 {
-  if(bitOrder == LSBFIRST) {
-    SPCR |= _BV(DORD);
-  } else {
-    SPCR &= ~(_BV(DORD));
-  }
-}
+	uint8_t mask;
 
-void SPIClass::setDataMode(uint8_t mode)
-{
-  SPCR = (SPCR & ~SPI_MODE_MASK) | mode;
-}
+	if (interruptMode > 1) return;
 
-void SPIClass::setClockDivider(uint8_t rate)
-{
-  SPCR = (SPCR & ~SPI_CLOCK_MASK) | (rate & SPI_CLOCK_MASK);
-  SPSR = (SPSR & ~SPI_2XCLOCK_MASK) | ((rate >> 2) & SPI_2XCLOCK_MASK);
+	noInterrupts();
+	switch (interruptNumber) {
+	#ifdef SPI_INT0_MASK
+	case 0: mask = SPI_INT0_MASK; break;
+	#endif
+	#ifdef SPI_INT1_MASK
+	case 1: mask = SPI_INT1_MASK; break;
+	#endif
+	#ifdef SPI_INT2_MASK
+	case 2: mask = SPI_INT2_MASK; break;
+	#endif
+	#ifdef SPI_INT3_MASK
+	case 3: mask = SPI_INT3_MASK; break;
+	#endif
+	#ifdef SPI_INT4_MASK
+	case 4: mask = SPI_INT4_MASK; break;
+	#endif
+	#ifdef SPI_INT5_MASK
+	case 5: mask = SPI_INT5_MASK; break;
+	#endif
+	#ifdef SPI_INT6_MASK
+	case 6: mask = SPI_INT6_MASK; break;
+	#endif
+	#ifdef SPI_INT7_MASK
+	case 7: mask = SPI_INT7_MASK; break;
+	#endif
+	default:
+		interruptMode = 2;
+		interrupts();
+		return;
+	}
+	interruptMode = 1;
+	interruptMask |= mask;
+	interrupts();
 }
 

SPI.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2010 by Cristian Maglie <c.maglie@bug.st>
+ * Copyright (c) 2014 by Paul Stoffregen <paul@pjrc.com> (Transaction API)
  * SPI Master library for arduino.
  *
  * This file is free software; you can redistribute it and/or modify
@@ -11,18 +12,22 @@
 #ifndef _SPI_H_INCLUDED
 #define _SPI_H_INCLUDED
 
-#include <stdio.h>
 #include <Arduino.h>
-#include <avr/pgmspace.h>
 
-#define SPI_CLOCK_DIV4 0x00
-#define SPI_CLOCK_DIV16 0x01
-#define SPI_CLOCK_DIV64 0x02
-#define SPI_CLOCK_DIV128 0x03
-#define SPI_CLOCK_DIV2 0x04
-#define SPI_CLOCK_DIV8 0x05
-#define SPI_CLOCK_DIV32 0x06
-//#define SPI_CLOCK_DIV64 0x07
+// SPI_HAS_TRANSACTION means SPI has beginTransaction(), endTransaction(),
+// usingInterrupt(), and the actual clock speed names
+#define SPI_HAS_TRANSACTION 1
+
+// define SPI_AVR_EIMSK for AVR boards with external interrupt pins
+#if defined(__AVR__)
+#if defined(EIMSK)
+  #define SPI_AVR_EIMSK	 EIMSK
+#elif defined(GICR)
+  #define SPI_AVR_EIMSK	 GICR
+#elif defined(GIMSK)
+  #define SPI_AVR_EIMSK	 GIMSK
+#endif
+#endif
 
 #define SPI_MODE0 0x00
 #define SPI_MODE1 0x04
@@ -35,41 +40,150 @@
 
 class SPIClass {
 public:
-  inline static byte transfer(byte _data);
+	// Initialize the SPI library
+	static void begin();
+
+	// If SPI is to used from within an interrupt, this function registers
+	// that interrupt with the SPI library, so beginTransaction() can
+	// prevent conflicts.  The input interruptNumber is the number used
+	// with attachInterrupt.  If SPI is used from a different interrupt
+	// (eg, a timer), interruptNumber should be 255.
+	static void usingInterrupt(uint8_t interruptNumber);
+	#if defined(__arm__) && defined(CORE_TEENSY)
+	static void usingInterrupt(IRQ_NUMBER_t interruptName);
+	#endif
+
+	// Before using SPI.transfer() or asserting chip select pins,
+	// this function is used to gain exclusive access to the SPI bus
+	// and configure the correct settings.
+	inline static void beginTransaction(uint8_t clockDiv, uint8_t bitOrder, uint8_t dataMode) {
+		if (interruptMode > 0) {
+			#ifdef SPI_AVR_EIMSK
+			if (interruptMode == 1) {
+				interruptSave = SPI_AVR_EIMSK;
+				SPI_AVR_EIMSK &= ~interruptMask;
+			} else
+			#endif
+			{
+				interruptSave = SREG;
+				cli();
+			}
+		}
+		// these long expressions each compile to only 2 instructions
+		SPCR = _BV(SPE) | _BV(MSTR) | ((bitOrder == LSBFIRST) ? _BV(DORD) : 0) |
+			(dataMode & SPI_MODE_MASK) | (clockDiv & SPI_CLOCK_MASK);
+		SPSR = (clockDiv >> 2) & SPI_2XCLOCK_MASK;
+	}
 
-  // SPI Configuration methods
+	// Write a byte to the SPI bus (MOSI pin) and also receive (MISO pin)
+	inline static byte transfer(byte data) {
+		SPDR = data;
+		while (!(SPSR & _BV(SPIF))) ; // wait
+		return SPDR;
+	}
 
-  inline static void attachInterrupt();
-  inline static void detachInterrupt(); // Default
+	// After performing a group of transfers and releasing the chip select
+	// signal, this function allows others to access the SPI bus
+	inline static void endTransaction(void) {
+		if (interruptMode > 0) {
+			#ifdef SPI_AVR_EIMSK
+			if (interruptMode == 1) {
+				SPI_AVR_EIMSK = interruptSave;
+			} else
+			#endif
+			{
+				SREG = interruptSave;
+			}
+		}
+	}
 
-  static void begin(); // Default
-  static void end();
+	// Disable the SPI bus
+	static void end();
+
+	// This function is deprecated.	 New applications should use
+	// beginTransaction() to configure SPI settings.
+	inline static void setBitOrder(uint8_t bitOrder) {
+		if (bitOrder == LSBFIRST) SPCR |= _BV(DORD);
+		else SPCR &= ~(_BV(DORD));
+	}
+	// This function is deprecated.	 New applications should use
+	// beginTransaction() to configure SPI settings.
+	inline static void setDataMode(uint8_t dataMode) {
+		SPCR = (SPCR & ~SPI_MODE_MASK) | dataMode;
+	}
+	// This function is deprecated.	 New applications should use
+	// beginTransaction() to configure SPI settings.
+	inline static void setClockDivider(uint8_t clockDiv) {
+		SPCR = (SPCR & ~SPI_CLOCK_MASK) | (clockDiv & SPI_CLOCK_MASK);
+		SPSR = (SPSR & ~SPI_2XCLOCK_MASK) | ((clockDiv >> 2) & SPI_2XCLOCK_MASK);
+	}
+	// These undocumented functions should not be used.  SPI.transfer()
+	// polls the hardware flag which is automatically cleared as the
+	// AVR responds to SPI's interrupt
+	inline static void attachInterrupt() { SPCR |= _BV(SPIE); }
+	inline static void detachInterrupt() { SPCR &= ~_BV(SPIE); }
 
-  static void setBitOrder(uint8_t);
-  static void setDataMode(uint8_t);
-  static void setClockDivider(uint8_t);
 #if defined(__arm__) && defined(CORE_TEENSY)
-  inline void setMOSI(uint8_t pin) __attribute__((always_inline)) { SPCR.setMOSI(pin); }
-  inline void setMISO(uint8_t pin) __attribute__((always_inline)) { SPCR.setMISO(pin); }
-  inline void setSCK(uint8_t pin) __attribute__((always_inline)) { SPCR.setSCK(pin); }
+	inline void setMOSI(uint8_t pin) __attribute__((always_inline)) { SPCR.setMOSI(pin); }
+	inline void setMISO(uint8_t pin) __attribute__((always_inline)) { SPCR.setMISO(pin); }
+	inline void setSCK(uint8_t pin) __attribute__((always_inline)) { SPCR.setSCK(pin); }
 #endif
+
+private:
+	static uint8_t interruptMode; // 0=none, 1=mask, 2=global
+	static uint8_t interruptMask; // which interrupts to mask
+	static uint8_t interruptSave; // temp storage, to restore state
 };
 
 extern SPIClass SPI;
 
-byte SPIClass::transfer(byte _data) {
-  SPDR = _data;
-  while (!(SPSR & _BV(SPIF)))
-    ;
-  return SPDR;
-}
 
-void SPIClass::attachInterrupt() {
-  SPCR |= _BV(SPIE);
-}
+#define SPI_CLOCK_DIV4 0x00
+#define SPI_CLOCK_DIV16 0x01
+#define SPI_CLOCK_DIV64 0x02
+#define SPI_CLOCK_DIV128 0x03
+#define SPI_CLOCK_DIV2 0x04
+#define SPI_CLOCK_DIV8 0x05
+#define SPI_CLOCK_DIV32 0x06
+
+// mapping of interrupt numbers to bits within SPI_AVR_EIMSK
+#ifdef SPI_AVR_EIMSK
+#if defined(__AVR_ATmega32U4__)
+  #define SPI_INT0_MASK	 (1<<INT0)
+  #define SPI_INT1_MASK	 (1<<INT1)
+  #define SPI_INT2_MASK	 (1<<INT2)
+  #define SPI_INT3_MASK	 (1<<INT3)
+  #define SPI_INT4_MASK	 (1<<INT6)
+#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
+  #define SPI_INT0_MASK	 (1<<INT0)
+  #define SPI_INT1_MASK	 (1<<INT1)
+  #define SPI_INT2_MASK	 (1<<INT2)
+  #define SPI_INT3_MASK	 (1<<INT3)
+  #define SPI_INT4_MASK	 (1<<INT4)
+  #define SPI_INT5_MASK	 (1<<INT5)
+  #define SPI_INT6_MASK	 (1<<INT6)
+  #define SPI_INT7_MASK	 (1<<INT7)
+#elif defined(EICRA) && defined(EICRB) && defined(EIMSK)
+  #define SPI_INT0_MASK	 (1<<INT4)
+  #define SPI_INT1_MASK	 (1<<INT5)
+  #define SPI_INT2_MASK	 (1<<INT0)
+  #define SPI_INT3_MASK	 (1<<INT1)
+  #define SPI_INT4_MASK	 (1<<INT2)
+  #define SPI_INT5_MASK	 (1<<INT3)
+  #define SPI_INT6_MASK	 (1<<INT6)
+  #define SPI_INT7_MASK	 (1<<INT7)
+#else
+  #ifdef INT0
+  #define SPI_INT0_MASK	 (1<<INT0)
+  #endif
+  #ifdef INT1
+  #define SPI_INT1_MASK	 (1<<INT1)
+  #endif
+  #ifdef INT2
+  #define SPI_INT2_MASK	 (1<<INT2)
+  #endif
+#endif
+#endif //SPI_AVR_EIMSK
 
-void SPIClass::detachInterrupt() {
-  SPCR &= ~_BV(SPIE);
-}
 
 #endif