ahoneybun/qmk_firmware
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update Temperature board driver to be AVR32 compatible when the ADC peripheral driver is eventually ported. Make architecture includes explicit for both the AVR32 and the AVR8, to make way for future architecture ports.

Browse source 
Add SPI driver aliases for the old function names in the AVR8 driver, so that existing code will still compile against the new version.
This commit is contained in:
Dean Camera 2010-02-23 03:51:17 +00:00
parent c24027f3b5
commit e11fddfe66
18 changed files with 138 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

2
LUFA/Drivers/Peripheral/ADC.h
View file

@ -58,6 +58,8 @@
#endif
/* Includes: */
#include "../../Common/Common.h"
#if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || \
defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB647__) || \
defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || \

61
LUFA/Drivers/Peripheral/AVR32/SPI.h
View file

@ -82,58 +82,69 @@
/** Initialises the SPI subsystem, ready for transfers. Must be called before calling any other
* SPI routines.
*
* \note The individual AVR32 chip select control registers are left at their defaults; it is up to the user
* to configure these seperately once the SPI module has been initialized.
*
* \note The physical GPIO pins for the AVR32's SPI are not altered; it is up to the user to
* configure these seperately to connect the SPI module to the desired GPIO pins via the
* GPIO MUX registers.
*
* \param[in] SPIOptions SPI Options, a mask consisting of one of each of the SPI_SPEED_*
* and SPI_MODE_* masks
*/
static inline void SPI_Init(const uint8_t SPIOptions)
static inline void SPI_Init(const uintN_t SPIOptions)
{
AVR32_SPI.cr = AVR32_SPI_CR_SPIEN_MASK | AVR32_SPI_CR_SWRST_MASK;
AVR32_SPI.cr = (AVR32_SPI_CR_SPIEN_MASK | AVR32_SPI_CR_SWRST_MASK);
AVR32_SPI.mr = SPIOptions;
}
/** Turns off the SPI driver, disabling and returning used hardware to their default configuration. */
static inline void SPI_ShutDown(void)
{
AVR32_SPI.cr = AVR32_SPI_CR_SPIDIS_MASK;
}
/** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.
/** Sends and receives a transfer through the SPI interface, blocking until the transfer is complete.
* The width of the data that is transferred is dependant on the settings of the currently selected
* peripheral.
*
* \param[in] Byte Byte to send through the SPI interface
* \param[in] Data Data to send through the SPI interface
*
* \return Response byte from the attached SPI device
* \return Response data from the attached SPI device
*/
static inline uint8_t SPI_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline uint8_t SPI_TransferByte(const uint8_t Byte)
static inline uint16_t SPI_Transfer(const uint16_t Data) ATTR_ALWAYS_INLINE;
static inline uint16_t SPI_Transfer(const uint16_t Data)
{
AVR32_SPI.tdr = Byte;
// TODO: Wait for receive
AVR32_SPI.TDR.td = Data;
while (!(AVR32_SPI.SR.tdre));
return AVR32_SPI.rdr;
}
/** Sends a byte through the SPI interface, blocking until the transfer is complete. The response
* byte sent to from the attached SPI device is ignored.
/** Sends a transfer through the SPI interface, blocking until the transfer is complete. The response
* data sent to from the attached SPI device is ignored. The width of the data that is transferred is
* dependant on the settings of the currently selected peripheral.
*
* \param[in] Byte Byte to send through the SPI interface
* \param[in] Data Data to send through the SPI interface
*/
static inline void SPI_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline void SPI_SendByte(const uint8_t Byte)
static inline void SPI_Send(const uint16_t Data) ATTR_ALWAYS_INLINE;
static inline void SPI_Send(const uint16_t Data)
{
AVR32_SPI.tdr = Byte;
// TODO: Wait for receive
AVR32_SPI.TDR.td = Data;
while (!(AVR32_SPI.SR.tdre));
}
/** Sends a dummy byte through the SPI interface, blocking until the transfer is complete. The response
* byte from the attached SPI device is returned.
/** Sends a dummy transfer through the SPI interface, blocking until the transfer is complete. The response
* data from the attached SPI device is returned. The width of the data that is transferred is dependant on
* the settings of the currently selected peripheral.
*
* \return The response byte from the attached SPI device
* \return The response data from the attached SPI device
*/
static inline uint8_t SPI_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline uint8_t SPI_ReceiveByte(void)
static inline uint16_t SPI_Receive(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline uint16_t SPI_Receive(void)
{
AVR32_SPI.tdr = 0x00;
// TODO: Wait for receive
return AVR32_SPI.rdr;
AVR32_SPI.TDR.td = 0x0000;
while (!(AVR32_SPI.SR.tdre));
return AVR32_SPI.RDR.rd;
}
/* Disable C linkage for C++ Compilers: */

2
LUFA/Drivers/Peripheral/AVR8/ADC.h
View file

@ -51,8 +51,6 @@
#define __ADC_AVR8_H__
/* Includes: */
#include "../../../Common/Common.h"
#include <avr/io.h>
#include <stdbool.h>

37
LUFA/Drivers/Peripheral/AVR8/SPI.h
View file

@ -118,7 +118,7 @@
* \param[in] SPIOptions SPI Options, a mask consisting of one of each of the SPI_SPEED_*,
* SPI_SCK_*, SPI_SAMPLE_* and SPI_MODE_* masks
*/
static inline void SPI_Init(const uint8_t SPIOptions)
static inline void SPI_Init(const uintN_t SPIOptions)
{
DDRB |= ((1 << 1) | (1 << 2));
PORTB |= ((1 << 0) | (1 << 3));
@ -143,14 +143,14 @@
/** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.
*
* \param[in] Byte Byte to send through the SPI interface
* \param[in] Data Byte to send through the SPI interface
*
* \return Response byte from the attached SPI device
*/
static inline uint8_t SPI_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline uint8_t SPI_TransferByte(const uint8_t Byte)
static inline uint8_t SPI_Transfer(const uint8_t Data) ATTR_ALWAYS_INLINE;
static inline uint8_t SPI_Transfer(const uint8_t Data)
{
SPDR = Byte;
SPDR = Data;
while (!(SPSR & (1 << SPIF)));
return SPDR;
}
@ -158,12 +158,12 @@
/** Sends a byte through the SPI interface, blocking until the transfer is complete. The response
* byte sent to from the attached SPI device is ignored.
*
* \param[in] Byte Byte to send through the SPI interface
* \param[in] Data Byte to send through the SPI interface
*/
static inline void SPI_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline void SPI_SendByte(const uint8_t Byte)
static inline void SPI_Send(const uint8_t Data) ATTR_ALWAYS_INLINE;
static inline void SPI_Send(const uint8_t Data)
{
SPDR = Byte;
SPDR = Data;
while (!(SPSR & (1 << SPIF)));
}
@ -172,13 +172,28 @@
*
* \return The response byte from the attached SPI device
*/
static inline uint8_t SPI_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline uint8_t SPI_ReceiveByte(void)
static inline uint8_t SPI_Receive(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline uint8_t SPI_Receive(void)
{
SPDR = 0x00;
while (!(SPSR & (1 << SPIF)));
return SPDR;
}
#if defined(__DOXYGEN__)
/** Alias for \ref SPI_Transfer(), for compatibility with legacy LUFA applications. */
static inline uint8_t SPI_TransferByte(const uint8_t Byte) ATTR_DEPRECATED;
/** Alias for \ref SPI_Send(), for compatibility with legacy LUFA applications. */
static inline void SPI_SendByte(const uint8_t Byte) ATTR_DEPRECATED;
/** Alias for \ref SPI_Receive(), for compatibility with legacy LUFA applications. */
static inline uint8_t SPI_ReceiveByte(void) ATTR_DEPRECATED;
#else
#define SPI_TransferByte(x) SPI_Transfer(x)
#define SPI_SendByte(x) SPI_Send(x)
#define SPI_ReceiveByte() SPI_Receive()
#endif
/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)

2
LUFA/Drivers/Peripheral/AVR8/TWI.h
View file

@ -51,8 +51,6 @@
#define __TWI_AVR8_H__
/* Includes: */
#include "../../../Common/Common.h"
#include <avr/io.h>
#include <stdbool.h>
#include <util/twi.h>

4
LUFA/Drivers/Peripheral/SPI.h
View file

@ -59,9 +59,11 @@
#endif
/* Includes: */
#include "../../Common/Common.h"
#if defined(__AVR32__)
#include "AVR32/SPI.h"
#else
#elif defined(__AVR__)
#include "AVR8/SPI.h"
#endif

8
LUFA/Drivers/Peripheral/Serial.h
View file

@ -60,15 +60,15 @@
#endif
/* Includes: */
#include "../../Common/Common.h"
#include "../Misc/TerminalCodes.h"
#if defined(__AVR32__)
#include "AVR32/Serial.h"
#else
#elif defined(__AVR__)
#include "AVR8/Serial.h"
#endif
#include "../../Common/Common.h"
#include "../Misc/TerminalCodes.h"
/* Enable C linkage for C++ Compilers: */
#if defined(__cplusplus)
extern "C" {

2
LUFA/Drivers/Peripheral/SerialStream.h
View file

@ -57,6 +57,8 @@
#include <avr/io.h>
#include <stdio.h>
#include "../../Common/Common.h"
#include "Serial.h"
/* Enable C linkage for C++ Compilers: */

2
LUFA/Drivers/Peripheral/TWI.h
View file

@ -57,6 +57,8 @@
#endif
/* Includes: */
#include "../../Common/Common.h"
#if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || \
defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB647__) || \
defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || \