Add partial support for the Atmel A3BU Xplained's Dataflash IC (physical USART-as...

diff --git a/LUFA/CodeTemplates/DriverStubs/Dataflash.h b/LUFA/CodeTemplates/DriverStubs/Dataflash.h
index 5edd26f..4ab1b8d 100644 (file)
--- a/LUFA/CodeTemplates/DriverStubs/Dataflash.h
+++ b/LUFA/CodeTemplates/DriverStubs/Dataflash.h
@@ -88,6 +88,38 @@
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 

+                       /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)
+                       {
+                               return SPI_TransferByte(Byte);
+                       }
+
+                       /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        */
+                       static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline void Dataflash_SendByte(const uint8_t Byte)
+                       {
+                               SPI_SendByte(Byte);
+                       }
+
+                       /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
+                       static inline uint8_t Dataflash_ReceiveByte(void)
+                       {
+                               return SPI_ReceiveByte();
+                       }
+

                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected
                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected

diff --git a/LUFA/Common/BoardTypes.h b/LUFA/Common/BoardTypes.h
index 7a141ac..efd80f9 100644 (file)
--- a/LUFA/Common/BoardTypes.h
+++ b/LUFA/Common/BoardTypes.h
@@ -83,10 +83,10 @@
                        /** Selects the BUMBLEB specific board drivers, using the officially recommended peripheral layout. */
                        #define BOARD_BUMBLEB       6
 
                        /** Selects the BUMBLEB specific board drivers, using the officially recommended peripheral layout. */
                        #define BOARD_BUMBLEB       6
 

-                       /** Selects the XPLAIN (Revision 2 or newer) specific board drivers, including LED and Dataflash driver. */
+                       /** Selects the XPLAIN (Revision 2 or newer) specific board drivers, including LED and Dataflash drivers. */

                        #define BOARD_XPLAIN        7
 
                        #define BOARD_XPLAIN        7
 

-                       /** Selects the XPLAIN (Revision 1) specific board drivers, including LED and Dataflash driver. */
+                       /** Selects the XPLAIN (Revision 1) specific board drivers, including LED and Dataflash drivers. */

                        #define BOARD_XPLAIN_REV1   8
 
                        /** Selects the EVK527 specific board drivers, including Temperature, Button, Dataflash, Joystick and LED drivers. */
                        #define BOARD_XPLAIN_REV1   8
 
                        /** Selects the EVK527 specific board drivers, including Temperature, Button, Dataflash, Joystick and LED drivers. */


@@ -156,7 +156,7 @@
                        /** Selects the Atmel EVK1104 specific board drivers, including the Button and LED drivers. */
                        #define BOARD_EVK1104       30
                        
                        /** Selects the Atmel EVK1104 specific board drivers, including the Button and LED drivers. */
                        #define BOARD_EVK1104       30
                        

-                       /** Selects the Atmel XMEGA A3BU Xplained specific board drivers, including the Button and LED drivers. */
+                       /** Selects the Atmel XMEGA A3BU Xplained specific board drivers, including Dataflash, Button and LED drivers. */

                        #define BOARD_A3BU_XPLAINED 31
 
                        #if !defined(__DOXYGEN__)
                        #define BOARD_A3BU_XPLAINED 31
 
                        #if !defined(__DOXYGEN__)

diff --git a/LUFA/Drivers/Board/AVR8/EVK527/Dataflash.h b/LUFA/Drivers/Board/AVR8/EVK527/Dataflash.h
index 0b496a8..5424dc7 100644 (file)
--- a/LUFA/Drivers/Board/AVR8/EVK527/Dataflash.h
+++ b/LUFA/Drivers/Board/AVR8/EVK527/Dataflash.h
@@ -92,6 +92,38 @@
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 

+                       /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)
+                       {
+                               return SPI_TransferByte(Byte);
+                       }
+
+                       /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        */
+                       static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline void Dataflash_SendByte(const uint8_t Byte)
+                       {
+                               SPI_SendByte(Byte);
+                       }
+
+                       /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
+                       static inline uint8_t Dataflash_ReceiveByte(void)
+                       {
+                               return SPI_ReceiveByte();
+                       }
+

                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected
                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected

diff --git a/LUFA/Drivers/Board/AVR8/STK525/Dataflash.h b/LUFA/Drivers/Board/AVR8/STK525/Dataflash.h
index c29f18a..5b38bf7 100644 (file)
--- a/LUFA/Drivers/Board/AVR8/STK525/Dataflash.h
+++ b/LUFA/Drivers/Board/AVR8/STK525/Dataflash.h
@@ -92,6 +92,38 @@
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 

+                       /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)
+                       {
+                               return SPI_TransferByte(Byte);
+                       }
+
+                       /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        */
+                       static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline void Dataflash_SendByte(const uint8_t Byte)
+                       {
+                               SPI_SendByte(Byte);
+                       }
+
+                       /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
+                       static inline uint8_t Dataflash_ReceiveByte(void)
+                       {
+                               return SPI_ReceiveByte();
+                       }
+

                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected
                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected

diff --git a/LUFA/Drivers/Board/AVR8/STK526/Dataflash.h b/LUFA/Drivers/Board/AVR8/STK526/Dataflash.h
index 7f8f728..b056802 100644 (file)
--- a/LUFA/Drivers/Board/AVR8/STK526/Dataflash.h
+++ b/LUFA/Drivers/Board/AVR8/STK526/Dataflash.h
@@ -92,6 +92,38 @@
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 

+                       /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)
+                       {
+                               return SPI_TransferByte(Byte);
+                       }
+
+                       /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        */
+                       static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline void Dataflash_SendByte(const uint8_t Byte)
+                       {
+                               SPI_SendByte(Byte);
+                       }
+
+                       /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
+                       static inline uint8_t Dataflash_ReceiveByte(void)
+                       {
+                               return SPI_ReceiveByte();
+                       }
+

                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected
                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected

diff --git a/LUFA/Drivers/Board/AVR8/USBKEY/Dataflash.h b/LUFA/Drivers/Board/AVR8/USBKEY/Dataflash.h
index f3af9bf..9808987 100644 (file)
--- a/LUFA/Drivers/Board/AVR8/USBKEY/Dataflash.h
+++ b/LUFA/Drivers/Board/AVR8/USBKEY/Dataflash.h
@@ -95,6 +95,38 @@
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 

+                       /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)
+                       {
+                               return SPI_TransferByte(Byte);
+                       }
+
+                       /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        */
+                       static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline void Dataflash_SendByte(const uint8_t Byte)
+                       {
+                               SPI_SendByte(Byte);
+                       }
+
+                       /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
+                       static inline uint8_t Dataflash_ReceiveByte(void)
+                       {
+                               return SPI_ReceiveByte();
+                       }
+

                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected
                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected

diff --git a/LUFA/Drivers/Board/AVR8/XPLAIN/Dataflash.h b/LUFA/Drivers/Board/AVR8/XPLAIN/Dataflash.h
index 42b9b77..71ff72b 100644 (file)
--- a/LUFA/Drivers/Board/AVR8/XPLAIN/Dataflash.h
+++ b/LUFA/Drivers/Board/AVR8/XPLAIN/Dataflash.h
@@ -98,6 +98,38 @@
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 
                                DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
                        }
 

+                       /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)
+                       {
+                               return SPI_TransferByte(Byte);
+                       }
+
+                       /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
+                        *
+                        *  \param[in] Byte of data to send to the dataflash
+                        */
+                       static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
+                       static inline void Dataflash_SendByte(const uint8_t Byte)
+                       {
+                               SPI_SendByte(Byte);
+                       }
+
+                       /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.
+                        *
+                        *  \return Last response byte from the dataflash
+                        */
+                       static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
+                       static inline uint8_t Dataflash_ReceiveByte(void)
+                       {
+                               return SPI_ReceiveByte();
+                       }
+

                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected
                        /** Determines the currently selected dataflash chip.
                         *
                         *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected

diff --git a/LUFA/Drivers/Board/Dataflash.h b/LUFA/Drivers/Board/Dataflash.h
index ff71e6f..f3d6dc4 100644 (file)
--- a/LUFA/Drivers/Board/Dataflash.h
+++ b/LUFA/Drivers/Board/Dataflash.h
@@ -206,30 +206,18 @@
                         *  \return Last response byte from the dataflash
                         */
                        static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
                         *  \return Last response byte from the dataflash
                         */
                        static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;

-                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)
-                       {
-                               return SPI_TransferByte(Byte);
-                       }

 
                        /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
                         *
                         *  \param[in] Byte of data to send to the dataflash
                         */
                        static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
 
                        /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
                         *
                         *  \param[in] Byte of data to send to the dataflash
                         */
                        static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;

-                       static inline void Dataflash_SendByte(const uint8_t Byte)
-                       {
-                               SPI_SendByte(Byte);
-                       }

 
                        /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.
                         *
                         *  \return Last response byte from the dataflash
                         */
                        static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
 
                        /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.
                         *
                         *  \return Last response byte from the dataflash
                         */
                        static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;

-                       static inline uint8_t Dataflash_ReceiveByte(void)
-                       {
-                               return SPI_ReceiveByte();
-                       }

 
                /* Includes: */
                        #if (BOARD == BOARD_NONE)
 
                /* Includes: */
                        #if (BOARD == BOARD_NONE)


@@ -244,6 +232,8 @@
                                #include "AVR8/XPLAIN/Dataflash.h"
                        #elif (BOARD == BOARD_EVK527)
                                #include "AVR8/EVK527/Dataflash.h"
                                #include "AVR8/XPLAIN/Dataflash.h"
                        #elif (BOARD == BOARD_EVK527)
                                #include "AVR8/EVK527/Dataflash.h"

+                       #elif (BOARD == BOARD_A3BU_XPLAINED)
+                               #include "XMEGA/A3BU_XPLAINED/Dataflash.h"                      

                        #else
                                #include "Board/Dataflash.h"
                        #endif
                        #else
                                #include "Board/Dataflash.h"
                        #endif

diff --git a/LUFA/Drivers/Board/XMEGA/A3BU_XPLAINED/Dataflash.h b/LUFA/Drivers/Board/XMEGA/A3BU_XPLAINED/Dataflash.h
new file mode 100644 (file)
index 0000000..a03878f
--- /dev/null
+++ b/LUFA/Drivers/Board/XMEGA/A3BU_XPLAINED/Dataflash.h
@@ -0,0 +1,220 @@
+/*\r
+             LUFA Library\r
+     Copyright (C) Dean Camera, 2011.\r
+\r
+  dean [at] fourwalledcubicle [dot] com\r
+           www.lufa-lib.org\r
+*/\r
+\r
+/*\r
+  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)\r
+\r
+  Permission to use, copy, modify, distribute, and sell this\r
+  software and its documentation for any purpose is hereby granted\r
+  without fee, provided that the above copyright notice appear in\r
+  all copies and that both that the copyright notice and this\r
+  permission notice and warranty disclaimer appear in supporting\r
+  documentation, and that the name of the author not be used in\r
+  advertising or publicity pertaining to distribution of the\r
+  software without specific, written prior permission.\r
+\r
+  The author disclaim all warranties with regard to this\r
+  software, including all implied warranties of merchantability\r
+  and fitness.  In no event shall the author be liable for any\r
+  special, indirect or consequential damages or any damages\r
+  whatsoever resulting from loss of use, data or profits, whether\r
+  in an action of contract, negligence or other tortious action,\r
+  arising out of or in connection with the use or performance of\r
+  this software.\r
+*/\r
+\r
+/** \file\r
+ *  \brief Board specific Dataflash driver header for the Atmel XMEGA A3BU Xplained.\r
+ *  \copydetails Group_Dataflash_A3BU_XPLAINED\r
+ *\r
+ *  \note This file should not be included directly. It is automatically included as needed by the dataflash driver\r
+ *        dispatch header located in LUFA/Drivers/Board/Dataflash.h.\r
+ */\r
+\r
+/** \ingroup Group_Dataflash\r
+ *  \defgroup Group_Dataflash_A3BU_XPLAINED XMEGA A3BU Xplained.\r
+ *  \brief Board specific Dataflash driver header for the Atmel XMEGA A3BU Xplained.\r
+ *\r
+ *  Board specific Dataflash driver header for the Atmel XMEGA A3BU Xplained board.\r
+ *\r
+ *  @{\r
+ */\r
+\r
+#ifndef __DATAFLASH_A3BU_XPLAINED_H__\r
+#define __DATAFLASH_A3BU_XPLAINED_H__\r
+\r
+       /* Includes: */\r
+               #include "../../../../Common/Common.h"\r
+               #include "../../../Misc/AT45DB642D.h"\r
+\r
+       /* Preprocessor Checks: */\r
+               #if !defined(__INCLUDE_FROM_DATAFLASH_H)\r
+                       #error Do not include this file directly. Include LUFA/Drivers/Board/Dataflash.h instead.\r
+               #endif\r
+\r
+       /* Private Interface - For use in library only: */\r
+       #if !defined(__DOXYGEN__)\r
+               /* Macros: */\r
+                       #define DATAFLASH_CHIPCS_MASK                (1 << 4)\r
+                       #define DATAFLASH_CHIPCS_PORT                PORTF\r
+       #endif\r
+\r
+       /* Public Interface - May be used in end-application: */\r
+               /* Macros: */\r
+                       /** Constant indicating the total number of dataflash ICs mounted on the selected board. */\r
+                       #define DATAFLASH_TOTALCHIPS                 1\r
+\r
+                       /** Mask for no dataflash chip selected. */\r
+                       #define DATAFLASH_NO_CHIP                    DATAFLASH_CHIPCS_MASK\r
+\r
+                       /** Mask for the first dataflash chip selected. */\r
+                       #define DATAFLASH_CHIP1                      0\r
+\r
+                       /** Internal main memory page size for the board's dataflash ICs. */\r
+                       #define DATAFLASH_PAGE_SIZE                  1024\r
+\r
+                       /** Total number of pages inside each of the board's dataflash ICs. */\r
+                       #define DATAFLASH_PAGES                      8192\r
+\r
+               /* Inline Functions: */\r
+                       /** Initializes the dataflash driver so that commands and data may be sent to an attached dataflash IC.\r
+                        *  The microcontroller's SPI driver MUST be initialized before any of the dataflash commands are used.\r
+                        */\r
+                       static inline void Dataflash_Init(void)\r
+                       {\r
+                               DATAFLASH_CHIPCS_PORT.DIRSET = DATAFLASH_CHIPCS_MASK;\r
+                               DATAFLASH_CHIPCS_PORT.OUTSET = DATAFLASH_CHIPCS_MASK;\r
+                       }\r
+\r
+                       /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.\r
+                        *\r
+                        *  \param[in] Byte of data to send to the dataflash\r
+                        *\r
+                        *  \return Last response byte from the dataflash\r
+                        */\r
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
+                       static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)\r
+                       {\r
+                               // TODO\r
+                               return 0;\r
+                       }\r
+\r
+                       /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.\r
+                        *\r
+                        *  \param[in] Byte of data to send to the dataflash\r
+                        */\r
+                       static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
+                       static inline void Dataflash_SendByte(const uint8_t Byte)\r
+                       {\r
+                               // TODO\r
+                       }\r
+\r
+                       /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.\r
+                        *\r
+                        *  \return Last response byte from the dataflash\r
+                        */\r
+                       static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
+                       static inline uint8_t Dataflash_ReceiveByte(void)\r
+                       {\r
+                               // TODO\r
+                               return 0;\r
+                       }\r
+\r
+                       /** Determines the currently selected dataflash chip.\r
+                        *\r
+                        *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected\r
+                        *  or a DATAFLASH_CHIPn mask (where n is the chip number).\r
+                        */\r
+                       static inline uint8_t Dataflash_GetSelectedChip(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
+                       static inline uint8_t Dataflash_GetSelectedChip(void)\r
+                       {\r
+                               return (DATAFLASH_CHIPCS_PORT.OUT & DATAFLASH_CHIPCS_MASK);\r
+                       }\r
+\r
+                       /** Selects the given dataflash chip.\r
+                        *\r
+                        *  \param[in]  ChipMask  Mask of the Dataflash IC to select, in the form of DATAFLASH_CHIPn mask (where n is\r
+                        *              the chip number).\r
+                        */\r
+                       static inline void Dataflash_SelectChip(const uint8_t ChipMask) ATTR_ALWAYS_INLINE;\r
+                       static inline void Dataflash_SelectChip(const uint8_t ChipMask)\r
+                       {\r
+                               DATAFLASH_CHIPCS_PORT.OUT = ((DATAFLASH_CHIPCS_PORT.OUT & ~DATAFLASH_CHIPCS_MASK) | ChipMask);\r
+                       }\r
+\r
+                       /** Deselects the current dataflash chip, so that no dataflash is selected. */\r
+                       static inline void Dataflash_DeselectChip(void) ATTR_ALWAYS_INLINE;\r
+                       static inline void Dataflash_DeselectChip(void)\r
+                       {\r
+                               Dataflash_SelectChip(DATAFLASH_NO_CHIP);\r
+                       }\r
+\r
+                       /** Selects a dataflash IC from the given page number, which should range from 0 to\r
+                        *  ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1). For boards containing only one\r
+                        *  dataflash IC, this will select DATAFLASH_CHIP1. If the given page number is outside\r
+                        *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
+                        *  are deselected.\r
+                        *\r
+                        *  \param[in] PageAddress  Address of the page to manipulate, ranging from\r
+                        *                          0 to ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r
+                        */\r
+                       static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
+                       {\r
+                               Dataflash_DeselectChip();\r
+\r
+                               if (PageAddress >= (DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS))\r
+                                 return;\r
+\r
+                               if (PageAddress & 0x01)\r
+                                 Dataflash_SelectChip(DATAFLASH_CHIP2);\r
+                               else\r
+                                 Dataflash_SelectChip(DATAFLASH_CHIP1);\r
+                       }\r
+\r
+                       /** Toggles the select line of the currently selected dataflash IC, so that it is ready to receive\r
+                        *  a new command.\r
+                        */\r
+                       static inline void Dataflash_ToggleSelectedChipCS(void)\r
+                       {\r
+                               uint8_t SelectedChipMask = Dataflash_GetSelectedChip();\r
+\r
+                               Dataflash_DeselectChip();\r
+                               Dataflash_SelectChip(SelectedChipMask);\r
+                       }\r
+\r
+                       /** Spin-loops while the currently selected dataflash is busy executing a command, such as a main\r
+                        *  memory page program or main memory to buffer transfer.\r
+                        */\r
+                       static inline void Dataflash_WaitWhileBusy(void)\r
+                       {\r
+                               Dataflash_ToggleSelectedChipCS();\r
+                               Dataflash_SendByte(DF_CMD_GETSTATUS);\r
+                               while (!(Dataflash_ReceiveByte() & DF_STATUS_READY));\r
+                               Dataflash_ToggleSelectedChipCS();\r
+                       }\r
+\r
+                       /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
+                        *  dataflash commands which require a complete 24-bit address.\r
+                        *\r
+                        *  \param[in] PageAddress  Page address within the selected dataflash IC\r
+                        *  \param[in] BufferByte   Address within the dataflash's buffer\r
+                        */\r
+                       static inline void Dataflash_SendAddressBytes(uint16_t PageAddress,\r
+                                                                     const uint16_t BufferByte)\r
+                       {\r
+                               PageAddress >>= 1;\r
+\r
+                               Dataflash_SendByte(PageAddress >> 5);\r
+                               Dataflash_SendByte((PageAddress << 3) | (BufferByte >> 8));\r
+                               Dataflash_SendByte(BufferByte);\r
+                       }\r
+\r
+#endif\r
+\r
+/** @} */\r
+\r