Merge pull request #33 from inmarket/master

GADC implementation, TDISP fix and GDISP fixes

8 files changed, 2434 insertions, 2230 deletions

diff --git a/include/gadc/gadc.h b/include/gadc/gadc.h
index 5c490cb9..be7af516 100644
--- a/include/gadc/gadc.h
+++ b/include/gadc/gadc.h
@@ -1,250 +1,258 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    ChibiOS/GFX is free software; you can redistribute it and/or modify

-    it under the terms of the GNU General Public License as published by

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-/**

- * @file    include/gadc/gadc.h

- * @brief   GADC - Periodic ADC subsystem header file.

- *

- * @addtogroup GADC

- *

- * @details	The reason why ChibiOS/GFX has it's own ADC abstraction is because

- *			the Chibi-OS drivers are very CPU specific and do not

- *			provide a way across all hardware platforms to create periodic

- *			ADC conversions. There are also issues with devices with different

- *			characteristics or periodic requirements on the same ADC

- *			device (but different channels). This layer attempts to solve these

- *			problems to provide a architecture neutral API. It also provides extra

- *			features such as multi-buffer chaining for high speed ADC sources.

- *			It provides one high speed virtual ADC device (eg a microphone) and

- *			numerous low speed (less than 100Hz) virtual ADC devices (eg dials,

- *			temperature sensors etc). The high speed device has timer based polling

- *			to ensure exact conversion periods and a buffer management system.

- *			The low speed devices are assumed to be non-critical timing devices

- *			and do not have any buffer management.

- *			Note that while only one high speed device has been provided it can

- *			be used to read multiple physical ADC channels on the one physical

- *			ADC device.

- *			All callback routines are thread based unlike the Chibi-OS interrupt based

- *			routines.

- *

- * @{

- */

-

-#ifndef _GADC_H

-#define _GADC_H

-

-#include "gfx.h"

-

-#if GFX_USE_GADC || defined(__DOXYGEN__)

-

-/* Include the driver defines */

-#include "gadc_lld_config.h"

-

-/*===========================================================================*/

-/* Type definitions                                                          */

-/*===========================================================================*/

-

-// Event types for GADC

-#define GEVENT_ADC			(GEVENT_GADC_FIRST+0)

-

-/**

- * @brief   The High Speed ADC event structure.

- * @{

- */

-typedef struct GEventADC_t {

-	/**

-	 * @brief The type of this event (GEVENT_ADC)

-	 */

-	GEventType		type;

-	/**

-	 * @brief The event flags

-	 */

-	uint16_t		flags;

-		/**

-		 * @brief   The event flag values.

-		 * @{

-		 */

-		#define	GADC_HSADC_LOSTEVENT		0x0001		/**< @brief The last GEVENT_HSDADC event was lost */

-		/** @} */

-	/**

-	 * @brief The number of conversions in the buffer

-	 */

-	size_t			count;

-	/**

-	 * @brief The buffer containing the conversion samples

-	 */

-	adcsample_t		*buffer;

-	} GEventADC;

-

-/**

- * @brief A callback function (executed in a thread context)

- */

-typedef void (*GADCCallbackFunction)(adcsample_t *buffer, void *param);

-

-/*===========================================================================*/

-/* External declarations.                                                    */

-/*===========================================================================*/

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-/**

- * @brief				Initialise the high speed ADC.

- * @details				Initialises but does not start the conversions.

- *

- * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.

- * @param[in] frequency		The frequency to create ADC conversions

- * @param[in] buffer		The static buffer to put the ADC samples into.

- * @param[in] bufcount		The total number of conversions that will fit in the buffer.

- * @param[in] countPerEvent	The number of conversions to do before returning an event.

- *

- * @note				If the high speed ADC is running it will be stopped.

- * @note				Due to a bug in Chibi-OS countPerEvent must be even. If bufcount is not

- * 						evenly divisable by countPerEvent, the remainder must also be even.

- * @note				The physdev parameter may be used to turn on more than one ADC channel.

- * 						Each channel is then interleaved into the provided buffer. Note 'bufcount'

- * 						and 'countPerEvent' parameters describe the number of conversions not the

- * 						number of samples.

- * 						As an example, if physdev turns on 2 devices then the buffer contains

- * 						alternate device samples and the buffer must contain 2 * bufcount samples.

- * 						The exact meaning of physdev is hardware dependent.

- * @note				The buffer is circular. When the end of the buffer is reached it will start

- * 						putting data into the beginning of the buffer again.

- * @note				The event listener must process the event (and the data in it) before the

- * 						next event occurs. If not, the following event will be lost.

- * @note				If bufcount is evenly divisable by countPerEvent, then every event will return

- * 						countPerEvent conversions. If bufcount is not evenly divisable, it will return

- * 						a block of samples containing less than countPerEvent samples when it reaches the

- * 						end of the buffer.

- * @note				While the high speed ADC is running, low speed conversions can only occur at

- * 						the frequency of the high speed events. Thus if high speed events are

- * 						being created at 50Hz (eg countPerEvent = 100, frequency = 5kHz) then the maximum

- * 						frequency for low speed conversions is likely to be 50Hz (although it might be

- * 						100Hz on some hardware).

- *

- * @api

- */

-void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer, size_t bufcount, size_t samplesPerEvent);

-

-#if GFX_USE_GEVENT || defined(__DOXYGEN__)

-	/**

-	 * @brief   			Turn on sending results to the GEVENT sub-system.

-	 * @details				Returns a GSourceHandle to listen for GEVENT_ADC events.

-	 *

-	 * @note				The high speed ADC will not use the GEVENT system unless this is

-	 * 						called first. This saves processing time if the application does

-	 * 						not want to use the GEVENT sub-system for the high speed ADC.

-	 * 						Once turned on it cannot be turned off.

-	 * @note				The high speed ADC is capable of signalling via this method and a binary semaphore

-	 * 						at the same time.

-	 *

-	 * @api

-	 */

-	GSourceHandle gadcHighSpeedGetSource(void);

-#endif

-

-/**

- * @brief				Allow retrieving of results from the high speed ADC using a Binary Semaphore and a static event buffer.

- *

- * @param[in] pbsem			The binary semaphore is signaled when data is available.

- * @param[in] pEvent		The static event buffer to place the result information.

- *

- * @note				Passing a NULL for pbsem or pEvent will turn off signalling via this method.

- * @note				The high speed ADC is capable of signalling via this method and the GEVENT

- * 						sub-system at the same time.

- *

- * @api

- */

-void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent);

-

-/**

- * @brief   Start the high speed ADC conversions.

- * @pre		It must have been initialised first with @p gadcHighSpeedInit()

- *

- * @api

- */

-GSourceHandle gadcHighSpeedStart(void);

-

-/**

- * @brief   Stop the high speed ADC conversions.

- *

- * @api

- */

-void gadcHighSpeedStop(void);

-

-/**

- * @brief	Perform a single low speed ADC conversion

- * @details	Blocks until the conversion is complete

- * @pre		This should not be called from within a GTimer callback as this routine

- * 			blocks until the conversion is ready.

- *

- * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.

- * @param[in] buffer		The static buffer to put the ADC samples into.

- *

- * @note	This may take a while to complete if the high speed ADC is running as the

- * 			conversion is interleaved with the high speed ADC conversions on a buffer

- * 			completion.

- * @note	The result buffer must be large enough to store one sample per device

- * 			described by the 'physdev' parameter.

- * @note	If calling this routine would exceed @p GADC_MAX_LOWSPEED_DEVICES simultaneous low

- * 			speed devices, the routine will wait for an available slot to complete the

- * 			conversion.

- * @note	Specifying more than one device in physdev is possible but discouraged as the

- * 			calculations to ensure the high speed ADC correctness will be incorrect. Symptoms

- * 			from over-running the high speed ADC include high speed samples being lost.

- *

- * @api

- */

-void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer);

-

-/**

- * @brief	Perform a low speed ADC conversion with callback (in a thread context)

- * @details	Returns FALSE if there are no free low speed ADC slots. See @p GADC_MAX_LOWSPEED_DEVICES for details.

- *

- * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.

- * @param[in] buffer		The static buffer to put the ADC samples into.

- * @param[in] fn			The callback function to call when the conversion is complete.

- * @param[in] param			A parameter to pass to the callback function.

- *

- * @note	This may be safely called from within a GTimer callback.

- * @note	The callback may take a while to occur if the high speed ADC is running as the

- * 			conversion is interleaved with the high speed ADC conversions on a buffer

- * 			completion.

- * @note	The result buffer must be large enough to store one sample per device

- * 			described by the 'physdev' parameter.

- * @note	As this routine uses a low speed ADC, it asserts if you try to run more than @p GADC_MAX_LOWSPEED_DEVICES

- * 			at the same time.

- * @note	Specifying more than one device in physdev is possible but discouraged as the

- * 			calculations to ensure the high speed ADC correctness will be incorrect. Symptoms

- * 			from over-running the high speed ADC include high speed samples being lost.

- *

- * @api

- */

-bool gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param);

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif /* GFX_USE_GADC */

-

-#endif /* _GADC_H */

-/** @} */

-

+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @file    include/gadc/gadc.h
+ * @brief   GADC - Periodic ADC subsystem header file.
+ *
+ * @addtogroup GADC
+ *
+ * @details	The reason why ChibiOS/GFX has it's own ADC abstraction is because
+ *			the Chibi-OS drivers are very CPU specific and do not
+ *			provide a way across all hardware platforms to create periodic
+ *			ADC conversions. There are also issues with devices with different
+ *			characteristics or periodic requirements on the same ADC
+ *			device (but different channels). This layer attempts to solve these
+ *			problems to provide a architecture neutral API. It also provides extra
+ *			features such as multi-buffer chaining for high speed ADC sources.
+ *			It provides one high speed virtual ADC device (eg a microphone) and
+ *			numerous low speed (less than 100Hz) virtual ADC devices (eg dials,
+ *			temperature sensors etc). The high speed device has timer based polling
+ *			to ensure exact conversion periods and a buffer management system.
+ *			The low speed devices are assumed to be non-critical timing devices
+ *			and do not have any buffer management.
+ *			Note that while only one high speed device has been provided it can
+ *			be used to read multiple physical ADC channels on the one physical
+ *			ADC device.
+ *			All callback routines are thread based unlike the Chibi-OS interrupt based
+ *			routines.
+ *
+ * @{
+ */
+
+#ifndef _GADC_H
+#define _GADC_H
+
+#include "gfx.h"
+
+#if GFX_USE_GADC || defined(__DOXYGEN__)
+
+/* Include the driver defines */
+#include "gadc_lld_config.h"
+
+/*===========================================================================*/
+/* Type definitions                                                          */
+/*===========================================================================*/
+
+// Event types for GADC
+#define GEVENT_ADC			(GEVENT_GADC_FIRST+0)
+
+/**
+ * @brief   The High Speed ADC event structure.
+ * @{
+ */
+typedef struct GEventADC_t {
+	#if GFX_USE_GEVENT || defined(__DOXYGEN__)
+		/**
+		 * @brief The type of this event (GEVENT_ADC)
+		 */
+		GEventType		type;
+	#endif
+
+	/**
+	 * @brief The event flags
+	 */
+	uint16_t		flags;
+		/**
+		 * @brief   The event flag values.
+		 * @{
+		 */
+		#define	GADC_HSADC_LOSTEVENT		0x0001		/**< @brief The last GEVENT_HSDADC event was lost */
+		/** @} */
+	/**
+	 * @brief The number of conversions in the buffer
+	 */
+	size_t			count;
+	/**
+	 * @brief The buffer containing the conversion samples
+	 */
+	adcsample_t		*buffer;
+	} GEventADC;
+
+/**
+ * @brief A callback function (executed in a thread context)
+ */
+typedef void (*GADCCallbackFunction)(adcsample_t *buffer, void *param);
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief				Initialise the high speed ADC.
+ * @details				Initialises but does not start the conversions.
+ *
+ * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.
+ * @param[in] frequency		The frequency to create ADC conversions
+ * @param[in] buffer		The static buffer to put the ADC samples into.
+ * @param[in] bufcount		The total number of conversions that will fit in the buffer.
+ * @param[in] countPerEvent	The number of conversions to do before returning an event.
+ *
+ * @note				If the high speed ADC is running it will be stopped. The Event subsystem is
+ * 						disconnected from the high speed ADC and any binary semaphore event is forgotten.
+ * @note				bufcount must be greater than countPerEvent (usually 2 or more times) otherwise
+ * 						the buffer will be overwitten with new data while the application is still trying
+ * 						to process the old data.
+ * @note				Due to a bug in Chibi-OS countPerEvent must be even. If bufcount is not
+ * 						evenly divisable by countPerEvent, the remainder must also be even.
+ * @note				The physdev parameter may be used to turn on more than one ADC channel.
+ * 						Each channel is then interleaved into the provided buffer. Note 'bufcount'
+ * 						and 'countPerEvent' parameters describe the number of conversions not the
+ * 						number of samples.
+ * 						As an example, if physdev turns on 2 devices then the buffer contains
+ * 						alternate device samples and the buffer must contain 2 * bufcount samples.
+ * 						The exact meaning of physdev is hardware dependent.
+ * @note				The buffer is circular. When the end of the buffer is reached it will start
+ * 						putting data into the beginning of the buffer again.
+ * @note				The event listener must process the event (and the data in it) before the
+ * 						next event occurs. If not, the following event will be lost.
+ * @note				If bufcount is evenly divisable by countPerEvent, then every event will return
+ * 						countPerEvent conversions. If bufcount is not evenly divisable, it will return
+ * 						a block of samples containing less than countPerEvent samples when it reaches the
+ * 						end of the buffer.
+ * @note				While the high speed ADC is running, low speed conversions can only occur at
+ * 						the frequency of the high speed events. Thus if high speed events are
+ * 						being created at 50Hz (eg countPerEvent = 100, frequency = 5kHz) then the maximum
+ * 						frequency for low speed conversions is likely to be 50Hz (although it might be
+ * 						100Hz on some hardware).
+ *
+ * @api
+ */
+void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer, size_t bufcount, size_t samplesPerEvent);
+
+#if GFX_USE_GEVENT || defined(__DOXYGEN__)
+	/**
+	 * @brief   			Turn on sending results to the GEVENT sub-system.
+	 * @details				Returns a GSourceHandle to listen for GEVENT_ADC events.
+	 *
+	 * @note				The high speed ADC will not use the GEVENT system unless this is
+	 * 						called first. This saves processing time if the application does
+	 * 						not want to use the GEVENT sub-system for the high speed ADC.
+	 * 						Once turned on it can only be turned off by calling @p gadcHighSpeedInit() again.
+	 * @note				The high speed ADC is capable of signalling via this method and a binary semaphore
+	 * 						at the same time.
+	 *
+	 * @api
+	 */
+	GSourceHandle gadcHighSpeedGetSource(void);
+#endif
+
+/**
+ * @brief				Allow retrieving of results from the high speed ADC using a Binary Semaphore and a static event buffer.
+ *
+ * @param[in] pbsem			The binary semaphore is signaled when data is available.
+ * @param[in] pEvent		The static event buffer to place the result information.
+ *
+ * @note				Passing a NULL for pbsem or pEvent will turn off signalling via this method as will calling
+ * 						@p gadcHighSpeedInit().
+ * @note				The high speed ADC is capable of signalling via this method and the GEVENT
+ * 						sub-system at the same time.
+ *
+ * @api
+ */
+void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent);
+
+/**
+ * @brief   Start the high speed ADC conversions.
+ * @pre		It must have been initialised first with @p gadcHighSpeedInit()
+ *
+ * @api
+ */
+void gadcHighSpeedStart(void);
+
+/**
+ * @brief   Stop the high speed ADC conversions.
+ *
+ * @api
+ */
+void gadcHighSpeedStop(void);
+
+/**
+ * @brief	Perform a single low speed ADC conversion
+ * @details	Blocks until the conversion is complete
+ * @pre		This should not be called from within a GTimer callback as this routine
+ * 			blocks until the conversion is ready.
+ *
+ * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.
+ * @param[in] buffer		The static buffer to put the ADC samples into.
+ *
+ * @note	This may take a while to complete if the high speed ADC is running as the
+ * 			conversion is interleaved with the high speed ADC conversions on a buffer
+ * 			completion.
+ * @note	The result buffer must be large enough to store one sample per device
+ * 			described by the 'physdev' parameter.
+ * @note	If calling this routine would exceed @p GADC_MAX_LOWSPEED_DEVICES simultaneous low
+ * 			speed devices, the routine will wait for an available slot to complete the
+ * 			conversion.
+ * @note	Specifying more than one device in physdev is possible but discouraged as the
+ * 			calculations to ensure the high speed ADC correctness will be incorrect. Symptoms
+ * 			from over-running the high speed ADC include high speed samples being lost.
+ *
+ * @api
+ */
+void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer);
+
+/**
+ * @brief	Perform a low speed ADC conversion with callback (in a thread context)
+ * @details	Returns FALSE if there are no free low speed ADC slots. See @p GADC_MAX_LOWSPEED_DEVICES for details.
+ *
+ * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.
+ * @param[in] buffer		The static buffer to put the ADC samples into.
+ * @param[in] fn			The callback function to call when the conversion is complete.
+ * @param[in] param			A parameter to pass to the callback function.
+ *
+ * @note	This may be safely called from within a GTimer callback.
+ * @note	The callback may take a while to occur if the high speed ADC is running as the
+ * 			conversion is interleaved with the high speed ADC conversions on a buffer
+ * 			completion.
+ * @note	The result buffer must be large enough to store one sample per device
+ * 			described by the 'physdev' parameter.
+ * @note	As this routine uses a low speed ADC, it asserts if you try to run more than @p GADC_MAX_LOWSPEED_DEVICES
+ * 			at the same time.
+ * @note	Specifying more than one device in physdev is possible but discouraged as the
+ * 			calculations to ensure the high speed ADC correctness will be incorrect. Symptoms
+ * 			from over-running the high speed ADC include high speed samples being lost.
+ *
+ * @api
+ */
+bool_t gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GFX_USE_GADC */
+
+#endif /* _GADC_H */
+/** @} */
+
diff --git a/include/gadc/lld/gadc_lld.h b/include/gadc/lld/gadc_lld.h
new file mode 100644
index 00000000..f9cc8b47
--- /dev/null
+++ b/include/gadc/lld/gadc_lld.h
@@ -0,0 +1,190 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @file    include/gadc/lld/gadc_lld.h
+ * @brief   GADC - Periodic ADC driver header file.
+ *
+ * @defgroup Driver Driver
+ * @ingroup GADC
+ * @{
+ */
+
+#ifndef _GADC_LLD_H
+#define _GADC_LLD_H
+
+#include "gfx.h"
+
+#if GFX_USE_GADC || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Type definitions                                                          */
+/*===========================================================================*/
+
+/**
+ * @brief				The structure passed to start a timer conversion
+ * @note				We use the structure instead of parameters purely to save
+ * 						interrupt stack space which is very limited in some platforms.
+ * @{
+ */
+typedef struct GadcLldTimerData_t {
+	uint32_t		physdev;		/* @< A value passed to describe which physical ADC devices/channels to use. */
+	adcsample_t		*buffer;		/* @< The static buffer to put the ADC samples into. */
+	size_t			count;			/* @< The number of conversions to do before doing a callback and stopping the ADC. */
+	bool_t			now;			/* @< Trigger the first conversion now rather than waiting for the first timer interrupt (if possible) */
+	} GadcLldTimerData;
+/* @} */
+
+/**
+ * @brief				The structure passed to start a non-timer conversion
+ * @note				We use the structure instead of parameters purely to save
+ * 						interrupt stack space which is very limited in some platforms.
+ * @{
+ */
+typedef struct GadcLldNonTimerData_t {
+	uint32_t		physdev;		/* @< A value passed to describe which physical ADC devices/channels to use. */
+	adcsample_t		*buffer;		/* @< The static buffer to put the ADC samples into. */
+	} GadcLldNonTimerData;
+/* @} */
+
+/**
+ * @brief				These routines are the callbacks that the driver uses.
+ * @details				Defined in the high level GADC code.
+ *
+ * @notapi
+ * @{
+ */
+extern void GADC_ISR_CompleteI(ADCDriver *adcp, adcsample_t *buffer, size_t n);
+extern void GADC_ISR_ErrorI(ADCDriver *adcp, adcerror_t err);
+/**
+ * @}
+ */
+
+/**
+ * @brief				This can be incremented by the low level driver if a timer interrupt is missed.
+ * @details				Defined in the high level GADC code.
+ *
+ * @notapi
+ */
+extern volatile bool_t GADC_Timer_Missed;
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief				Initialise the driver
+ *
+ * @api
+ */
+void gadc_lld_init(void);
+
+/**
+ * @brief				Get the number of samples in a conversion.
+ * @details				Calculates and returns the number of samples per conversion for the specified physdev.
+ *
+ * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.
+ *
+ * @note				A physdev describing a mono device would return 1, a stereo device would return 2.
+ * 						For most ADC's physdev is a bitmap so it is only a matter of counting the bits.
+ *
+ * @api
+ */
+size_t gadc_lld_samples_per_conversion(uint32_t physdev);
+
+/**
+ * @brief				Start a periodic timer for high frequency conversions.
+ *
+ * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.
+ * @param[in] frequency		The frequency to create ADC conversions
+ *
+ * @note				The exact meaning of physdev is hardware dependent. It describes the channels
+ * 						the will be used later on when a "timer" conversion is actually scheduled.
+ * @note				It is assumed that the timer is capable of free-running even when the ADC
+ * 						is stopped or doing something else.
+ * @details				When a timer interrupt occurs a conversion should start if these is a "timer" conversion
+ * 						active.
+ * @note				If the ADC is stopped, doesn't have a "timer" conversion active or is currently executing
+ * 						a non-timer conversion then the interrupt can be ignored other than (optionally) incrementing
+ * 						the GADC_Timer_Missed variable.
+ *
+ * @api
+ */
+void gadc_lld_start_timer(uint32_t physdev, uint32_t frequency);
+
+/**
+ * @brief				Stop the periodic timer for high frequency conversions.
+ * @details				Also stops any current "timer" conversion (but not a current "non-timer" conversion).
+ *
+ * @param[in] physdev	A value passed to describe which physical ADC devices/channels in use.
+ *
+ * @note				The exact meaning of physdev is hardware dependent.
+ *
+ * @api
+ */
+void gadc_lld_stop_timer(uint32_t physdev);
+
+/**
+ * @brief				Start a "timer" conversion.
+ * @details				Starts a series of conversions triggered by the timer.
+ *
+ * @param[in] pgtd		Contains the parameters for the timer conversion.
+ *
+ * @note				The exact meaning of physdev is hardware dependent. It is likely described in the
+ * 						drivers gadc_lld_config.h
+ * @note				Some versions of ChibiOS actually call the callback function more than once, once
+ * 						at the half-way point and once on completion. The high level code handles this.
+ * @note				The driver should call @p GADC_ISR_CompleteI() when it completes the operation
+ * 						(or at the half-way point), or @p GAD_ISR_ErrorI() on an error.
+ * @note				The high level code ensures that this is not called while a non-timer conversion is in
+ * 						progress
+ *
+ * @iclass
+ */
+void gadc_lld_adc_timerI(GadcLldTimerData *pgtd);
+
+/**
+ * @brief				Start a "non-timer" conversion.
+ * @details				Starts a single conversion now.
+ *
+ * @param[in] pgntd		Contains the parameters for the non-timer conversion.
+ *
+ * @note				The exact meaning of physdev is hardware dependent. It is likely described in the
+ * 						drivers gadc_lld_config.h
+ * @note				The driver should call @p GADC_ISR_CompleteI() when it completes the operation
+ * 						or @p GAD_ISR_ErrorI() on an error.
+ * @note				The high level code ensures that this is not called while a timer conversion is in
+ * 						progress
+ *
+ * @iclass
+ */
+void gadc_lld_adc_nontimerI(GadcLldNonTimerData *pgntd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GFX_USE_GADC */
+
+#endif /* _GADC_LLD_H */
+/** @} */
diff --git a/include/gadc/options.h b/include/gadc/options.h
index dc5bd300..87708efe 100644
--- a/include/gadc/options.h
+++ b/include/gadc/options.h
@@ -1,57 +1,55 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    ChibiOS/GFX is free software; you can redistribute it and/or modify

-    it under the terms of the GNU General Public License as published by

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file    include/gadc/options.h

- * @brief   GADC - Periodic ADC subsystem options header file.

- *

- * @addtogroup GADC

- * @{

- */

-

-#ifndef _GADC_OPTIONS_H

-#define _GADC_OPTIONS_H

-

-/**

- * @name    GADC Functionality to be included

- * @{

- */

-/**

- * @}

- *

- * @name    GADC Optional Sizing Parameters

- * @{

- */

-	/**

-	 * @brief   The maximum simultaneous GADC low speed device conversions

-	 * @details	Defaults to 4

-	 * @note	This value must be less than the number of conversions that can occur

-	 * 			in a single high speed ADC cycle including the high speed ADC conversion.

-	 * 			For example, if the ADC can run at 132k samples per second and the high speed

-	 * 			virtual ADC is using 44kHz then GADC_MAX_LOWSPEED_DEVICES should be set to

-	 * 			132/44 - 1 = 2

-	 */

-	#ifndef GADC_MAX_LOWSPEED_DEVICES

-		#define GADC_MAX_LOWSPEED_DEVICES	4

-	#endif

-/** @} */

-

-#endif /* _GADC_OPTIONS_H */

-/** @} */

+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    include/gadc/options.h
+ * @brief   GADC - Periodic ADC subsystem options header file.
+ *
+ * @addtogroup GADC
+ * @{
+ */
+
+#ifndef _GADC_OPTIONS_H
+#define _GADC_OPTIONS_H
+
+/**
+ * @name    GADC Functionality to be included
+ * @{
+ */
+/**
+ * @}
+ *
+ * @name    GADC Optional Sizing Parameters
+ * @{
+ */
+	/**
+	 * @brief   The maximum GADC sample rate
+	 * @details	Defaults to 44000
+	 * @note	This value must be less than half the maximum sample rate allowed by the CPU.
+	 * 			This is to ensure there is time between high speed samples to perform low
+	 * 			speed device sampling.
+	 */
+	#ifndef GADC_MAX_HIGH_SPEED_SAMPLERATE
+		#define GADC_MAX_HIGH_SPEED_SAMPLERATE	44000
+	#endif
+/** @} */
+
+#endif /* _GADC_OPTIONS_H */
+/** @} */
diff --git a/include/gdisp/gdisp.h b/include/gdisp/gdisp.h
index b2e6df53..0e51a5d8 100644
--- a/include/gdisp/gdisp.h
+++ b/include/gdisp/gdisp.h
@@ -1,291 +1,291 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    ChibiOS/GFX is free software; you can redistribute it and/or modify

-    it under the terms of the GNU General Public License as published by

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file    include/gdisp/gdisp.h

- * @brief   GDISP Graphic Driver subsystem header file.

- *

- * @addtogroup GDISP

- *

- * @details		The GDISP module provides high level abstraction to interface pixel oriented graphic displays.

- *

- * @pre			GFX_USE_GDISP must be set to TRUE in gfxconf.h

- *

- * @{

- */

-

-#ifndef _GDISP_H

-#define _GDISP_H

-

-#include "gfx.h"

-

-/* This type definition is defined here as it gets used in other gfx sub-systems even

- * if GFX_USE_GDISP is FALSE.

- */

-

-/**

- * @brief   The type for a coordinate or length on the screen.

- */

-typedef int16_t	coord_t;

-

-#if GFX_USE_GDISP || defined(__DOXYGEN__)

-

-/*===========================================================================*/

-/* Driver constants.														 */

-/*===========================================================================*/

-

-/**

- * @name   Some basic colors

- * @{

- */

-#define White			HTML2COLOR(0xFFFFFF)

-#define Black			HTML2COLOR(0x000000)

-#define Gray			HTML2COLOR(0x808080)

-#define Grey			Gray

-#define Blue			HTML2COLOR(0x0000FF)

-#define Red				HTML2COLOR(0xFF0000)

-#define Fuchsia			HTML2COLOR(0xFF00FF)

-#define Magenta			Fuchsia

-#define Green			HTML2COLOR(0x008000)

-#define Yellow			HTML2COLOR(0xFFFF00)

-#define Aqua			HTML2COLOR(0x00FFFF)

-#define Cyan			Aqua

-#define Lime			HTML2COLOR(0x00FF00)

-#define Maroon			HTML2COLOR(0x800000)

-#define Navy			HTML2COLOR(0x000080)

-#define Olive			HTML2COLOR(0x808000)

-#define Purple			HTML2COLOR(0x800080)

-#define Silver			HTML2COLOR(0xC0C0C0)

-#define Teal			HTML2COLOR(0x008080)

-#define Orange			HTML2COLOR(0xFFA500)

-#define Pink			HTML2COLOR(0xFFC0CB)

-#define SkyBlue			HTML2COLOR(0x87CEEB)

-/** @} */

-

-/*===========================================================================*/

-/* Low Level Driver details and error checks.                                */

-/*===========================================================================*/

-

-/* Include the low level driver information */

-#include "gdisp/lld/gdisp_lld.h"

-

-/*===========================================================================*/

-/* Type definitions                                                          */

-/*===========================================================================*/

-

-/**

- * @brief   Type for the text justification.

- */

-typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t;

-/**

- * @brief   Type for the font metric.

- */

-typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t;

-

-/*===========================================================================*/

-/* External declarations.                                                    */

-/*===========================================================================*/

-

-#if (GDISP_NEED_TEXT && GDISP_OLD_FONT_DEFINITIONS) || defined(__DOXYGEN__)

-	#if GDISP_INCLUDE_FONT_SMALL

-		extern const struct font fontSmall;

-		extern const struct font fontSmallDouble;

-		extern const struct font fontSmallNarrow;

-	#endif

-	#if GDISP_INCLUDE_FONT_LARGER

-		extern const struct font fontLarger;

-		extern const struct font fontLargerDouble;

-		extern const struct font fontLargerNarrow;

-	#endif

-	#if GDISP_INCLUDE_FONT_UI1

-		extern const struct font fontUI1;

-		extern const struct font fontUI1Double;

-		extern const struct font fontUI1Narrow;

-	#endif

-	#if GDISP_INCLUDE_FONT_UI2

-		extern const struct font fontUI2;

-		extern const struct font fontUI2Double;

-		extern const struct font fontUI2Narrow;

-	#endif

-	#if GDISP_INCLUDE_FONT_LARGENUMBERS

-		extern const struct font fontLargeNumbers;

-		extern const struct font fontLargeNumbersDouble;

-		extern const struct font fontLargeNumbersNarrow;

-	#endif

-#endif

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC

-	/* These routines can be hardware accelerated

-	 *	- Do not add a routine here unless it has also been added to the hardware acceleration layer

-	 */

-

-	/* Base Functions */

-	bool_t gdispInit(void);

-	bool_t gdispIsBusy(void);

-

-	/* Drawing Functions */

-	void gdispClear(color_t color);

-	void gdispDrawPixel(coord_t x, coord_t y, color_t color);

-	void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);

-	void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

-	void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);

-

-	/* Clipping Functions */

-	#if GDISP_NEED_CLIP

-	void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy);

-	#endif

-

-	/* Circle Functions */

-	#if GDISP_NEED_CIRCLE

-	void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color);

-	void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color);

-	#endif

-	

-	/* Ellipse Functions */

-	#if GDISP_NEED_ELLIPSE

-	void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

-	void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

-	#endif

-

-	/* Arc Functions */

-	#if GDISP_NEED_ARC

-	void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);

-	void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);

-	#endif

-

-	/* Basic Text Rendering Functions */

-	#if GDISP_NEED_TEXT

-	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color);

-	void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);

-	#endif

-	

-	/* Read a pixel Function */

-	#if GDISP_NEED_PIXELREAD

-	color_t gdispGetPixelColor(coord_t x, coord_t y);

-	#endif

-

-	/* Scrolling Function - clears the area scrolled out */

-	#if GDISP_NEED_SCROLL

-	void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);

-	#endif

-

-	/* Set driver specific control */

-	#if GDISP_NEED_CONTROL

-	void gdispControl(unsigned what, void *value);

-	#endif

-

-	/* Query driver specific data */

-	void *gdispQuery(unsigned what);

-

-#else

-

-	/* The same as above but use the low level driver directly if no multi-thread support is needed */

-	#define gdispInit(gdisp)									lld_gdisp_init()

-	#define gdispIsBusy()										FALSE

-	#define gdispClear(color)									lld_gdisp_clear(color)

-	#define gdispDrawPixel(x, y, color)							lld_gdisp_draw_pixel(x, y, color)

-	#define gdispDrawLine(x0, y0, x1, y1, color)				lld_gdisp_draw_line(x0, y0, x1, y1, color)

-	#define gdispFillArea(x, y, cx, cy, color)					lld_gdisp_fill_area(x, y, cx, cy, color)

-	#define gdispBlitAreaEx(x, y, cx, cy, sx, sy, scx, buf)		lld_gdisp_blit_area_ex(x, y, cx, cy, sx, sy, scx, buf)

-	#define gdispSetClip(x, y, cx, cy)							lld_gdisp_set_clip(x, y, cx, cy)

-	#define gdispDrawCircle(x, y, radius, color)				lld_gdisp_draw_circle(x, y, radius, color)

-	#define gdispFillCircle(x, y, radius, color)				lld_gdisp_fill_circle(x, y, radius, color)

-	#define gdispDrawArc(x, y, radius, sangle, eangle, color)	lld_gdisp_draw_arc(x, y, radius, sangle, eangle, color)

-	#define gdispFillArc(x, y, radius, sangle, eangle, color)	lld_gdisp_fill_arc(x, y, radius, sangle, eangle, color)

-	#define gdispDrawEllipse(x, y, a, b, color)					lld_gdisp_draw_ellipse(x, y, a, b, color)

-	#define gdispFillEllipse(x, y, a, b, color)					lld_gdisp_fill_ellipse(x, y, a, b, color)

-	#define gdispDrawChar(x, y, c, font, color)					lld_gdisp_draw_char(x, y, c, font, color)

-	#define gdispFillChar(x, y, c, font, color, bgcolor)		lld_gdisp_fill_char(x, y, c, font, color, bgcolor)

-	#define gdispGetPixelColor(x, y)							lld_gdisp_get_pixel_color(x, y)

-	#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor)	lld_gdisp_vertical_scroll(x, y, cx, cy, lines, bgcolor)

-	#define gdispControl(what, value)							lld_gdisp_control(what, value)

-	#define gdispQuery(what)									lld_gdisp_query(what)

-

-#endif

-

-/* These routines are not hardware accelerated

- *	- Do not add a hardware accelerated routines here.

- */

-

-/* Extra drawing functions */

-void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

-

-/* Extra Text Functions */

-#if GDISP_NEED_TEXT

-	void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color);

-	void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor);

-	void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify);

-	void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify);

-	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric);

-	coord_t gdispGetCharWidth(char c, font_t font);

-	coord_t gdispGetStringWidth(const char* str, font_t font);

-	font_t gdispOpenFont(const char *name);

-	void gdispCloseFont(font_t font);

-	const char *gdispGetFontName(font_t font);

-#endif

-

-/* Extra Arc Functions */

-#if GDISP_NEED_ARC

-	void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);

-	void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);

-#endif

-

-/* Support routine for packed pixel formats */

-#ifndef gdispPackPixels

-	void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);

-#endif

-

-/* 

- * Macro definitions

- */

-

-/* Now obsolete functions */

-#define gdispBlitArea(x, y, cx, cy, buffer)		gdispBlitAreaEx(x, y, cx, cy, 0, 0, cx, buffer)

-

-/* Macro definitions for common gets and sets */

-#define gdispSetPowerMode(powerMode)			gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode))

-#define gdispSetOrientation(newOrientation)		gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(unsigned)(newOrientation))

-#define gdispSetBacklight(percent)				gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent))

-#define gdispSetContrast(percent)				gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent))

-

-#define gdispGetWidth()							((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH))

-#define gdispGetHeight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT))

-#define gdispGetPowerMode()						((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER))

-#define gdispGetOrientation()					((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION))

-#define gdispGetBacklight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT))

-#define gdispGetContrast()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST))

-

-/* More interesting macro's */

-#define gdispUnsetClip()						gdispSetClip(0,0,gdispGetWidth(),gdispGetHeight())

-

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif /* GFX_USE_GDISP */

-

-#endif /* _GDISP_H */

-/** @} */

-

+/*
+    ChibiOS/GFX - Copyright (C) 2012
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    include/gdisp/gdisp.h
+ * @brief   GDISP Graphic Driver subsystem header file.
+ *
+ * @addtogroup GDISP
+ *
+ * @details		The GDISP module provides high level abstraction to interface pixel oriented graphic displays.
+ *
+ * @pre			GFX_USE_GDISP must be set to TRUE in gfxconf.h
+ *
+ * @{
+ */
+
+#ifndef _GDISP_H
+#define _GDISP_H
+
+#include "gfx.h"
+
+/* This type definition is defined here as it gets used in other gfx sub-systems even
+ * if GFX_USE_GDISP is FALSE.
+ */
+
+/**
+ * @brief   The type for a coordinate or length on the screen.
+ */
+typedef int16_t	coord_t;
+
+#if GFX_USE_GDISP || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver constants.														 */
+/*===========================================================================*/
+
+/**
+ * @name   Some basic colors
+ * @{
+ */
+#define White			HTML2COLOR(0xFFFFFF)
+#define Black			HTML2COLOR(0x000000)
+#define Gray			HTML2COLOR(0x808080)
+#define Grey			Gray
+#define Blue			HTML2COLOR(0x0000FF)
+#define Red				HTML2COLOR(0xFF0000)
+#define Fuchsia			HTML2COLOR(0xFF00FF)
+#define Magenta			Fuchsia
+#define Green			HTML2COLOR(0x008000)
+#define Yellow			HTML2COLOR(0xFFFF00)
+#define Aqua			HTML2COLOR(0x00FFFF)
+#define Cyan			Aqua
+#define Lime			HTML2COLOR(0x00FF00)
+#define Maroon			HTML2COLOR(0x800000)
+#define Navy			HTML2COLOR(0x000080)
+#define Olive			HTML2COLOR(0x808000)
+#define Purple			HTML2COLOR(0x800080)
+#define Silver			HTML2COLOR(0xC0C0C0)
+#define Teal			HTML2COLOR(0x008080)
+#define Orange			HTML2COLOR(0xFFA500)
+#define Pink			HTML2COLOR(0xFFC0CB)
+#define SkyBlue			HTML2COLOR(0x87CEEB)
+/** @} */
+
+/*===========================================================================*/
+/* Low Level Driver details and error checks.                                */
+/*===========================================================================*/
+
+/* Include the low level driver information */
+#include "gdisp/lld/gdisp_lld.h"
+
+/*===========================================================================*/
+/* Type definitions                                                          */
+/*===========================================================================*/
+
+/**
+ * @brief   Type for the text justification.
+ */
+typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t;
+/**
+ * @brief   Type for the font metric.
+ */
+typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t;
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#if (GDISP_NEED_TEXT && GDISP_OLD_FONT_DEFINITIONS) || defined(__DOXYGEN__)
+	#if GDISP_INCLUDE_FONT_SMALL
+		extern const struct font fontSmall;
+		extern const struct font fontSmallDouble;
+		extern const struct font fontSmallNarrow;
+	#endif
+	#if GDISP_INCLUDE_FONT_LARGER
+		extern const struct font fontLarger;
+		extern const struct font fontLargerDouble;
+		extern const struct font fontLargerNarrow;
+	#endif
+	#if GDISP_INCLUDE_FONT_UI1
+		extern const struct font fontUI1;
+		extern const struct font fontUI1Double;
+		extern const struct font fontUI1Narrow;
+	#endif
+	#if GDISP_INCLUDE_FONT_UI2
+		extern const struct font fontUI2;
+		extern const struct font fontUI2Double;
+		extern const struct font fontUI2Narrow;
+	#endif
+	#if GDISP_INCLUDE_FONT_LARGENUMBERS
+		extern const struct font fontLargeNumbers;
+		extern const struct font fontLargeNumbersDouble;
+		extern const struct font fontLargeNumbersNarrow;
+	#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC
+	/* These routines can be hardware accelerated
+	 *	- Do not add a routine here unless it has also been added to the hardware acceleration layer
+	 */
+
+	/* Base Functions */
+	bool_t gdispInit(void);
+	bool_t gdispIsBusy(void);
+
+	/* Drawing Functions */
+	void gdispClear(color_t color);
+	void gdispDrawPixel(coord_t x, coord_t y, color_t color);
+	void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
+	void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+	void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);
+
+	/* Clipping Functions */
+	#if GDISP_NEED_CLIP
+	void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy);
+	#endif
+
+	/* Circle Functions */
+	#if GDISP_NEED_CIRCLE
+	void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color);
+	void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color);
+	#endif
+	
+	/* Ellipse Functions */
+	#if GDISP_NEED_ELLIPSE
+	void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+	void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+	#endif
+
+	/* Arc Functions */
+	#if GDISP_NEED_ARC
+	void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
+	void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
+	#endif
+
+	/* Basic Text Rendering Functions */
+	#if GDISP_NEED_TEXT
+	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color);
+	void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
+	#endif
+	
+	/* Read a pixel Function */
+	#if GDISP_NEED_PIXELREAD
+	color_t gdispGetPixelColor(coord_t x, coord_t y);
+	#endif
+
+	/* Scrolling Function - clears the area scrolled out */
+	#if GDISP_NEED_SCROLL
+	void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
+	#endif
+
+	/* Set driver specific control */
+	#if GDISP_NEED_CONTROL
+	void gdispControl(unsigned what, void *value);
+	#endif
+
+	/* Query driver specific data */
+	void *gdispQuery(unsigned what);
+
+#else
+
+	/* The same as above but use the low level driver directly if no multi-thread support is needed */
+	#define gdispInit(gdisp)									gdisp_lld_init()
+	#define gdispIsBusy()										FALSE
+	#define gdispClear(color)									gdisp_lld_clear(color)
+	#define gdispDrawPixel(x, y, color)							gdisp_lld_draw_pixel(x, y, color)
+	#define gdispDrawLine(x0, y0, x1, y1, color)				gdisp_lld_draw_line(x0, y0, x1, y1, color)
+	#define gdispFillArea(x, y, cx, cy, color)					gdisp_lld_fill_area(x, y, cx, cy, color)
+	#define gdispBlitAreaEx(x, y, cx, cy, sx, sy, scx, buf)		gdisp_lld_blit_area_ex(x, y, cx, cy, sx, sy, scx, buf)
+	#define gdispSetClip(x, y, cx, cy)							gdisp_lld_set_clip(x, y, cx, cy)
+	#define gdispDrawCircle(x, y, radius, color)				gdisp_lld_draw_circle(x, y, radius, color)
+	#define gdispFillCircle(x, y, radius, color)				gdisp_lld_fill_circle(x, y, radius, color)
+	#define gdispDrawArc(x, y, radius, sangle, eangle, color)	gdisp_lld_draw_arc(x, y, radius, sangle, eangle, color)
+	#define gdispFillArc(x, y, radius, sangle, eangle, color)	gdisp_lld_fill_arc(x, y, radius, sangle, eangle, color)
+	#define gdispDrawEllipse(x, y, a, b, color)					gdisp_lld_draw_ellipse(x, y, a, b, color)
+	#define gdispFillEllipse(x, y, a, b, color)					gdisp_lld_fill_ellipse(x, y, a, b, color)
+	#define gdispDrawChar(x, y, c, font, color)					gdisp_lld_draw_char(x, y, c, font, color)
+	#define gdispFillChar(x, y, c, font, color, bgcolor)		gdisp_lld_fill_char(x, y, c, font, color, bgcolor)
+	#define gdispGetPixelColor(x, y)							gdisp_lld_get_pixel_color(x, y)
+	#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor)	gdisp_lld_vertical_scroll(x, y, cx, cy, lines, bgcolor)
+	#define gdispControl(what, value)							gdisp_lld_control(what, value)
+	#define gdispQuery(what)									gdisp_lld_query(what)
+
+#endif
+
+/* These routines are not hardware accelerated
+ *	- Do not add a hardware accelerated routines here.
+ */
+
+/* Extra drawing functions */
+void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+
+/* Extra Text Functions */
+#if GDISP_NEED_TEXT
+	void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color);
+	void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor);
+	void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify);
+	void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify);
+	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric);
+	coord_t gdispGetCharWidth(char c, font_t font);
+	coord_t gdispGetStringWidth(const char* str, font_t font);
+	font_t gdispOpenFont(const char *name);
+	void gdispCloseFont(font_t font);
+	const char *gdispGetFontName(font_t font);
+#endif
+
+/* Extra Arc Functions */
+#if GDISP_NEED_ARC
+	void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);
+	void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);
+#endif
+
+/* Support routine for packed pixel formats */
+#ifndef gdispPackPixels
+	void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);
+#endif
+
+/* 
+ * Macro definitions
+ */
+
+/* Now obsolete functions */
+#define gdispBlitArea(x, y, cx, cy, buffer)		gdispBlitAreaEx(x, y, cx, cy, 0, 0, cx, buffer)
+
+/* Macro definitions for common gets and sets */
+#define gdispSetPowerMode(powerMode)			gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode))
+#define gdispSetOrientation(newOrientation)		gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(unsigned)(newOrientation))
+#define gdispSetBacklight(percent)				gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent))
+#define gdispSetContrast(percent)				gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent))
+
+#define gdispGetWidth()							((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH))
+#define gdispGetHeight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT))
+#define gdispGetPowerMode()						((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER))
+#define gdispGetOrientation()					((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION))
+#define gdispGetBacklight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT))
+#define gdispGetContrast()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST))
+
+/* More interesting macro's */
+#define gdispUnsetClip()						gdispSetClip(0,0,gdispGetWidth(),gdispGetHeight())
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GFX_USE_GDISP */
+
+#endif /* _GDISP_H */
+/** @} */
+
diff --git a/include/gdisp/lld/emulation.c b/include/gdisp/lld/emulation.c
index 86301ed5..ecabc3fd 100644
--- a/include/gdisp/lld/emulation.c
+++ b/include/gdisp/lld/emulation.c
@@ -1,772 +1,772 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    ChibiOS/GFX is free software; you can redistribute it and/or modify

-    it under the terms of the GNU General Public License as published by

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file	include/gdisp/lld/emulation.c

- * @brief	GDISP emulation routines for stuff the driver dosen't support

- *

- * @addtogroup GDISP

- *

- * @details	Even though this is a software emulation of a low level driver

- *			most validation doesn't need to happen here as eventually

- *			we call a real low level driver routine and if validation is

- *			required - it will do it.

- *

- * @{

- */

-#ifndef GDISP_EMULATION_C

-#define GDISP_EMULATION_C

-

-#if GFX_USE_GDISP /*|| defined(__DOXYGEN__) */

-

-#ifndef GDISP_LLD_NO_STRUCT

-	static struct GDISPDriver {

-		coord_t				Width;

-		coord_t				Height;

-		gdisp_orientation_t	Orientation;

-		gdisp_powermode_t	Powermode;

-		uint8_t				Backlight;

-		uint8_t				Contrast;

-		#if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION

-			coord_t				clipx0, clipy0;

-			coord_t				clipx1, clipy1;		/* not inclusive */

-		#endif

-		} GDISP;

-#endif

-

-#if !GDISP_HARDWARE_CLEARS 

-	void lld_gdisp_clear(color_t color) {

-		lld_gdisp_fill_area(0, 0, GDISP.Width, GDISP.Height, color);

-	}

-#endif

-

-#if !GDISP_HARDWARE_LINES 

-	void lld_gdisp_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {

-		int16_t dy, dx;

-		int16_t addx, addy;

-		int16_t P, diff, i;

-

-		#if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL

-		// speed improvement if vertical or horizontal

-		if (x0 == x1) {

-			if (y1 > y0)

-				lld_gdisp_fill_area(x0, y0, 1, y1-y0+1, color);

-			else

-				lld_gdisp_fill_area(x0, y1, 1, y0-y1+1, color);

-			return;

-		}

-		if (y0 == y1) {

-			if (x1 > x0)

-				lld_gdisp_fill_area(x0, y0, x1-x0+1, 1, color);

-			else

-				lld_gdisp_fill_area(x0, y1, x0-x1+1, 1, color);

-			return;

-		}

-		#endif

-

-		if (x1 >= x0) {

-			dx = x1 - x0;

-			addx = 1;

-		} else {

-			dx = x0 - x1;

-			addx = -1;

-		}

-		if (y1 >= y0) {

-			dy = y1 - y0;

-			addy = 1;

-		} else {

-			dy = y0 - y1;

-			addy = -1;

-		}

-

-		if (dx >= dy) {

-			dy *= 2;

-			P = dy - dx;

-			diff = P - dx;

-

-			for(i=0; i<=dx; ++i) {

-				lld_gdisp_draw_pixel(x0, y0, color);

-				if (P < 0) {

-					P  += dy;

-					x0 += addx;

-				} else {

-					P  += diff;

-					x0 += addx;

-					y0 += addy;

-				}

-			}

-		} else {

-			dx *= 2;

-			P = dx - dy;

-			diff = P - dy;

-

-			for(i=0; i<=dy; ++i) {

-				lld_gdisp_draw_pixel(x0, y0, color);

-				if (P < 0) {

-					P  += dx;

-					y0 += addy;

-				} else {

-					P  += diff;

-					x0 += addx;

-					y0 += addy;

-				}

-			}

-		}

-	}

-#endif

-

-#if !GDISP_HARDWARE_FILLS

-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {

-		#if GDISP_HARDWARE_SCROLL

-			lld_gdisp_vertical_scroll(x, y, cx, cy, cy, color);

-		#elif GDISP_HARDWARE_LINES

-			coord_t x1, y1;

-			

-			x1 = x + cx - 1;

-			y1 = y + cy;

-			for(; y < y1; y++)

-				lld_gdisp_draw_line(x, y, x1, y, color);

-		#else

-			coord_t x0, x1, y1;

-			

-			x0 = x;

-			x1 = x + cx;

-			y1 = y + cy;

-			for(; y < y1; y++)

-				for(x = x0; x < x1; x++)

-					lld_gdisp_draw_pixel(x, y, color);

-		#endif

-	}

-#endif

-

-#if !GDISP_HARDWARE_BITFILLS

-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {

-			coord_t x0, x1, y1;

-			

-			x0 = x;

-			x1 = x + cx;

-			y1 = y + cy;

-			buffer += srcy*srccx+srcx;

-			srccx -= cx;

-			for(; y < y1; y++, buffer += srccx)

-				for(x=x0; x < x1; x++)

-					lld_gdisp_draw_pixel(x, y, *buffer++);

-	}

-#endif

-

-#if GDISP_NEED_CLIP && !GDISP_HARDWARE_CLIP

-	void lld_gdisp_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy) {

-		#if GDISP_NEED_VALIDATION

-			if (x >= GDISP.Width || y >= GDISP.Height || cx < 0 || cy < 0)

-				return;

-			if (x < 0) x = 0;

-			if (y < 0) y = 0;

-			if (x+cx > GDISP.Width) cx = GDISP.Width - x;

-			if (y+cy > GDISP.Height) cy = GDISP.Height - y;

-		#endif

-		GDISP.clipx0 = x;

-		GDISP.clipy0 = y;

-		GDISP.clipx1 = x+cx;

-		GDISP.clipy1 = y+cy;

-	}

-#endif

-

-#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES

-	void lld_gdisp_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color) {

-		coord_t a, b, P;

-

-		a = 0;

-		b = radius;

-		P = 1 - radius;

-

-		do {

-			lld_gdisp_draw_pixel(x+a, y+b, color);

-			lld_gdisp_draw_pixel(x+b, y+a, color);

-			lld_gdisp_draw_pixel(x-a, y+b, color);

-			lld_gdisp_draw_pixel(x-b, y+a, color);

-			lld_gdisp_draw_pixel(x+b, y-a, color);

-			lld_gdisp_draw_pixel(x+a, y-b, color);

-			lld_gdisp_draw_pixel(x-a, y-b, color);

-			lld_gdisp_draw_pixel(x-b, y-a, color);

-			if (P < 0)

-				P += 3 + 2*a++;

-			else

-				P += 5 + 2*(a++ - b--);

-		} while(a <= b);

-	}

-#endif

-

-#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS

-	void lld_gdisp_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color) {

-		coord_t a, b, P;

-		

-		a = 0;

-		b = radius;

-		P = 1 - radius;

-

-		do {

-			lld_gdisp_draw_line(x-a, y+b, x+a, y+b, color);

-			lld_gdisp_draw_line(x-a, y-b, x+a, y-b, color);

-			lld_gdisp_draw_line(x-b, y+a, x+b, y+a, color);

-			lld_gdisp_draw_line(x-b, y-a, x+b, y-a, color);

-			if (P < 0)

-				P += 3 + 2*a++;

-			else

-				P += 5 + 2*(a++ - b--);

-		} while(a <= b);

-	}

-#endif

-

-#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES

-	void lld_gdisp_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {

-		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */

-		long a2 = a*a, b2 = b*b;

-		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

-

-		do {

-			lld_gdisp_draw_pixel(x+dx, y+dy, color); /* I. Quadrant */

-			lld_gdisp_draw_pixel(x-dx, y+dy, color); /* II. Quadrant */

-			lld_gdisp_draw_pixel(x-dx, y-dy, color); /* III. Quadrant */

-			lld_gdisp_draw_pixel(x+dx, y-dy, color); /* IV. Quadrant */

-

-			e2 = 2*err;

-			if(e2 <  (2*dx+1)*b2) {

-				dx++;

-				err += (2*dx+1)*b2;

-			}

-			if(e2 > -(2*dy-1)*a2) {

-				dy--;

-				err -= (2*dy-1)*a2;

-			}

-		} while(dy >= 0); 

-

-		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */

-			lld_gdisp_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */

-			lld_gdisp_draw_pixel(x-dx, y, color);

-	   }   

-	}

-#endif

-

-#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS

-	void lld_gdisp_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {

-		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */

-		long a2 = a*a, b2 = b*b;

-		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

-

-		do {

-			lld_gdisp_draw_line(x-dx,y+dy,x+dx,y+dy, color);

-			lld_gdisp_draw_line(x-dx,y-dy,x+dx,y-dy, color);

-

-			e2 = 2*err;

-			if(e2 <  (2*dx+1)*b2) {

-				dx++;

-				err += (2*dx+1)*b2;

-			}

-			if(e2 > -(2*dy-1)*a2) {

-				dy--;

-				err -= (2*dy-1)*a2;

-			}

-		} while(dy >= 0); 

-

-		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */

-			lld_gdisp_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */

-			lld_gdisp_draw_pixel(x-dx, y, color);

-	   }   

-	}

-#endif

-

-#if GDISP_NEED_ARC && !GDISP_HARDWARE_ARCS

-

-	#include <math.h>

-

-	/*

-	 * @brief				Internal helper function for gdispDrawArc()

-	 *

-	 * @note				DO NOT USE DIRECTLY!

-	 *

-	 * @param[in] x, y		The middle point of the arc

-	 * @param[in] start		The start angle of the arc

-	 * @param[in] end		The end angle of the arc

-	 * @param[in] radius	The radius of the arc

-	 * @param[in] color		The color in which the arc will be drawn

-	 *

-	 * @notapi

-	 */

-	static void _draw_arc(coord_t x, coord_t y, uint16_t start, uint16_t end, uint16_t radius, color_t color) {

-	    if (/*start >= 0 && */start <= 180) {

-	        float x_maxI = x + radius*cos(start*M_PI/180);

-	        float x_minI;

-

-	        if (end > 180)

-	            x_minI = x - radius;

-	        else

-	            x_minI = x + radius*cos(end*M_PI/180);

-

-	        int a = 0;

-	        int b = radius;

-	        int P = 1 - radius;

-

-	        do {

-	            if(x-a <= x_maxI && x-a >= x_minI)

-	            	lld_gdisp_draw_pixel(x-a, y-b, color);

-	            if(x+a <= x_maxI && x+a >= x_minI)

-	            	lld_gdisp_draw_pixel(x+a, y-b, color);

-	            if(x-b <= x_maxI && x-b >= x_minI)

-	            	lld_gdisp_draw_pixel(x-b, y-a, color);

-	            if(x+b <= x_maxI && x+b >= x_minI)

-	            	lld_gdisp_draw_pixel(x+b, y-a, color);

-

-	            if (P < 0) {

-	                P = P + 3 + 2*a;

-	                a = a + 1;

-	            } else {

-	                P = P + 5 + 2*(a - b);

-	                a = a + 1;

-	                b = b - 1;

-	            }

-	        } while(a <= b);

-	    }

-

-	    if (end > 180 && end <= 360) {

-	        float x_maxII = x+radius*cos(end*M_PI/180);

-	        float x_minII;

-

-	        if(start <= 180)

-	            x_minII = x - radius;

-	        else

-	            x_minII = x+radius*cos(start*M_PI/180);

-

-	        int a = 0;

-	        int b = radius;

-	        int P = 1 - radius;

-

-	        do {

-	            if(x-a <= x_maxII && x-a >= x_minII)

-	            	lld_gdisp_draw_pixel(x-a, y+b, color);

-	            if(x+a <= x_maxII && x+a >= x_minII)

-	            	lld_gdisp_draw_pixel(x+a, y+b, color);

-	            if(x-b <= x_maxII && x-b >= x_minII)

-	            	lld_gdisp_draw_pixel(x-b, y+a, color);

-	            if(x+b <= x_maxII && x+b >= x_minII)

-	            	lld_gdisp_draw_pixel(x+b, y+a, color);

-

-	            if (P < 0) {

-	                P = P + 3 + 2*a;

-	                a = a + 1;

-	            } else {

-	                P = P + 5 + 2*(a - b);

-	                a = a + 1;

-	                b = b - 1;

-	            }

-	        } while (a <= b);

-	    }

-	}

-

-	void lld_gdisp_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {

-		if(endangle < startangle) {

-	        _draw_arc(x, y, startangle, 360, radius, color);

-	        _draw_arc(x, y, 0, endangle, radius, color);

-	    } else {

-	        _draw_arc(x, y, startangle, endangle, radius, color);

-		}

-	}

-#endif

-

-#if GDISP_NEED_ARC && !GDISP_HARDWARE_ARCFILLS

-	/*

-	 * @brief				Internal helper function for gdispDrawArc()

-	 *

-	 * @note				DO NOT USE DIRECTLY!

-	 *

-	 * @param[in] x, y		The middle point of the arc

-	 * @param[in] start		The start angle of the arc

-	 * @param[in] end		The end angle of the arc

-	 * @param[in] radius	The radius of the arc

-	 * @param[in] color		The color in which the arc will be drawn

-	 *

-	 * @notapi

-	 */

-	static void _fill_arc(coord_t x, coord_t y, uint16_t start, uint16_t end, uint16_t radius, color_t color) {

-	    if (/*start >= 0 && */start <= 180) {

-	        float x_maxI = x + radius*cos(start*M_PI/180);

-	        float x_minI;

-

-	        if (end > 180)

-	            x_minI = x - radius;

-	        else

-	            x_minI = x + radius*cos(end*M_PI/180);

-

-	        int a = 0;

-	        int b = radius;

-	        int P = 1 - radius;

-

-	        do {

-	            if(x-a <= x_maxI && x-a >= x_minI)

-	            	lld_gdisp_draw_line(x, y, x-a, y-b, color);

-	            if(x+a <= x_maxI && x+a >= x_minI)

-	            	lld_gdisp_draw_line(x, y, x+a, y-b, color);

-	            if(x-b <= x_maxI && x-b >= x_minI)

-	            	lld_gdisp_draw_line(x, y, x-b, y-a, color);

-	            if(x+b <= x_maxI && x+b >= x_minI)

-	            	lld_gdisp_draw_line(x, y, x+b, y-a, color);

-

-	            if (P < 0) {

-	                P = P + 3 + 2*a;

-	                a = a + 1;

-	            } else {

-	                P = P + 5 + 2*(a - b);

-	                a = a + 1;

-	                b = b - 1;

-	            }

-	        } while(a <= b);

-	    }

-

-	    if (end > 180 && end <= 360) {

-	        float x_maxII = x+radius*cos(end*M_PI/180);

-	        float x_minII;

-

-	        if(start <= 180)

-	            x_minII = x - radius;

-	        else

-	            x_minII = x+radius*cos(start*M_PI/180);

-

-	        int a = 0;

-	        int b = radius;

-	        int P = 1 - radius;

-

-	        do {

-	            if(x-a <= x_maxII && x-a >= x_minII)

-	            	lld_gdisp_draw_line(x, y, x-a, y+b, color);

-	            if(x+a <= x_maxII && x+a >= x_minII)

-	            	lld_gdisp_draw_line(x, y, x+a, y+b, color);

-	            if(x-b <= x_maxII && x-b >= x_minII)

-	            	lld_gdisp_draw_line(x, y, x-b, y+a, color);

-	            if(x+b <= x_maxII && x+b >= x_minII)

-	            	lld_gdisp_draw_line(x, y, x+b, y+a, color);

-

-	            if (P < 0) {

-	                P = P + 3 + 2*a;

-	                a = a + 1;

-	            } else {

-	                P = P + 5 + 2*(a - b);

-	                a = a + 1;

-	                b = b - 1;

-	            }

-	        } while (a <= b);

-	    }

-	}

-

-	void lld_gdisp_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {

-		if(endangle < startangle) {

-	        _fill_arc(x, y, startangle, 360, radius, color);

-	        _fill_arc(x, y, 0, endangle, radius, color);

-	    } else {

-	        _fill_arc(x, y, startangle, endangle, radius, color);

-		}

-	}

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

-	#include "gdisp/fonts.h"

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

-	void lld_gdisp_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color) {

-		const fontcolumn_t	*ptr;

-		fontcolumn_t		column;

-		coord_t				width, height, xscale, yscale;

-		coord_t				i, j, xs, ys;

-

-		/* Check we actually have something to print */

-		width = _getCharWidth(font, c);

-		if (!width) return;

-		

-		xscale = font->xscale;

-		yscale = font->yscale;

-		height = font->height * yscale;

-		width *= xscale;

-

-		ptr = _getCharData(font, c);

-

-		/* Loop through the data and display. The font data is LSBit first, down the column */

-		for(i=0; i < width; i+=xscale) {

-			/* Get the font bitmap data for the column */

-			column = *ptr++;

-			

-			/* Draw each pixel */

-			for(j=0; j < height; j+=yscale, column >>= 1) {

-				if (column & 0x01) {

-					for(xs=0; xs < xscale; xs++)

-						for(ys=0; ys < yscale; ys++)

-							lld_gdisp_draw_pixel(x+i+xs, y+j+ys, color);

-				}

-			}

-		}

-	}

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS

-	void lld_gdisp_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {

-		coord_t			width, height;

-		coord_t			xscale, yscale;

-		

-		/* Check we actually have something to print */

-		width = _getCharWidth(font, c);

-		if (!width) return;

-

-		xscale = font->xscale;

-		yscale = font->yscale;

-		height = font->height * yscale;

-		width *= xscale;

-

-		/* Method 1: Use background fill and then draw the text */

-		#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW

-			

-			/* Fill the area */

-			lld_gdisp_fill_area(x, y, width, height, bgcolor);

-			

-			/* Draw the text */

-			lld_gdisp_draw_char(x, y, c, font, color);

-

-		/* Method 2: Create a single column bitmap and then blit it */

-		#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-

-			/* Working buffer for fast non-transparent text rendering [patch by Badger]

-				This needs to be larger than the largest character we can print.

-				Assume the max is double sized by one column.

-			*/

-			static pixel_t		buf[sizeof(fontcolumn_t)*8*2];

-

-			#if GDISP_NEED_VALIDATION

-				/* Check our buffer is big enough */

-				if ((unsigned)height > sizeof(buf)/sizeof(buf[0]))	return;

-			#endif

-

-			ptr = _getCharData(font, c);

-

-			/* Loop through the data and display. The font data is LSBit first, down the column */

-			for(i = 0; i < width; i+=xscale) {

-				/* Get the font bitmap data for the column */

-				column = *ptr++;

-				

-				/* Draw each pixel */

-				for(j = 0; j < height; j+=yscale, column >>= 1) {

-					if (column & 0x01) {

-						for(ys=0; ys < yscale; ys++)

-							gdispPackPixels(buf, 1, j+ys, 0, color);

-					} else {

-						for(ys=0; ys < yscale; ys++)

-							gdispPackPixels(buf, 1, j+ys, 0, bgcolor);

-					}

-				}

-

-				for(xs=0; xs < xscale; xs++)

-					lld_gdisp_blit_area_ex(x+i+xs, y, 1, height, 0, 0, 1, buf);

-			}

-		}

-

-		/* Method 3: Create a character bitmap and then blit it */

-		#elif GDISP_HARDWARE_BITFILLS

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-			

-			/* Working buffer for fast non-transparent text rendering [patch by Badger]

-				This needs to be larger than the largest character we can print.

-				Assume the max is double sized.

-			*/

-			static pixel_t		buf[20*(sizeof(fontcolumn_t)*8)*2];

-

-			#if GDISP_NEED_VALIDATION

-				/* Check our buffer is big enough */

-				if ((unsigned)(width * height) > sizeof(buf)/sizeof(buf[0]))	return;

-			#endif

-

-			ptr = _getCharData(font, c);

-

-			/* Loop through the data and display. The font data is LSBit first, down the column */

-			for(i = 0; i < width; i+=xscale) {

-				/* Get the font bitmap data for the column */

-				column = *ptr++;

-				

-				/* Draw each pixel */

-				for(j = 0; j < height; j+=yscale, column >>= 1) {

-					if (column & 0x01) {

-						for(xs=0; xs < xscale; xs++)

-							for(ys=0; ys < yscale; ys++)

-								gdispPackPixels(buf, width, i+xs, j+ys, color);

-					} else {

-						for(xs=0; xs < xscale; xs++)

-							for(ys=0; ys < yscale; ys++)

-								gdispPackPixels(buf, width, i+xs, j+ys, bgcolor);

-					}

-				}

-			}

-

-			/* [Patch by Badger] Write all in one stroke */

-			lld_gdisp_blit_area_ex(x, y, width, height, 0, 0, width, buf);

-		}

-

-		/* Method 4: Draw pixel by pixel */

-		#else

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-

-			ptr = _getCharData(font, c);

-

-			/* Loop through the data and display. The font data is LSBit first, down the column */

-			for(i = 0; i < width; i+=xscale) {

-				/* Get the font bitmap data for the column */

-				column = *ptr++;

-				

-				/* Draw each pixel */

-				for(j = 0; j < height; j+=yscale, column >>= 1) {

-					if (column & 0x01) {

-						for(xs=0; xs < xscale; xs++)

-							for(ys=0; ys < yscale; ys++)

-								lld_gdisp_draw_pixel(x+i+xs, y+j+ys, color);

-					} else {

-						for(xs=0; xs < xscale; xs++)

-							for(ys=0; ys < yscale; ys++)

-								lld_gdisp_draw_pixel(x+i+xs, y+j+ys, bgcolor);

-					}

-				}

-			}

-		}

-		#endif

-	}

-#endif

-

-

-#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL

-	void lld_gdisp_control(unsigned what, void *value) {

-		(void)what;

-		(void)value;

-		/* Ignore everything */

-	}

-#endif

-

-#if !GDISP_HARDWARE_QUERY

-void *lld_gdisp_query(unsigned what) {

-	switch(what) {

-	case GDISP_QUERY_WIDTH:			return (void *)(unsigned)GDISP.Width;

-	case GDISP_QUERY_HEIGHT:		return (void *)(unsigned)GDISP.Height;

-	case GDISP_QUERY_POWER:			return (void *)(unsigned)GDISP.Powermode;

-	case GDISP_QUERY_ORIENTATION:	return (void *)(unsigned)GDISP.Orientation;

-	case GDISP_QUERY_BACKLIGHT:		return (void *)(unsigned)GDISP.Backlight;

-	case GDISP_QUERY_CONTRAST:		return (void *)(unsigned)GDISP.Contrast;

-	default:						return (void *)-1;

-	}

-}

-#endif

-

-#if GDISP_NEED_MSGAPI

-	void lld_gdisp_msg_dispatch(gdisp_lld_msg_t *msg) {

-		switch(msg->action) {

-		case GDISP_LLD_MSG_NOP:

-			break;

-		case GDISP_LLD_MSG_INIT:

-			lld_gdisp_init();

-			break;

-		case GDISP_LLD_MSG_CLEAR:

-			lld_gdisp_clear(msg->clear.color);

-			break;

-		case GDISP_LLD_MSG_DRAWPIXEL:

-			lld_gdisp_draw_pixel(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color);

-			break;

-		case GDISP_LLD_MSG_FILLAREA:

-			lld_gdisp_fill_area(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color);

-			break;

-		case GDISP_LLD_MSG_BLITAREA:

-			lld_gdisp_blit_area_ex(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.srcx, msg->blitarea.srcy, msg->blitarea.srccx, msg->blitarea.buffer);

-			break;

-		case GDISP_LLD_MSG_DRAWLINE:

-			lld_gdisp_draw_line(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color);

-			break;

-		#if GDISP_NEED_CLIP

-			case GDISP_LLD_MSG_SETCLIP:

-				lld_gdisp_set_clip(msg->setclip.x, msg->setclip.y, msg->setclip.cx, msg->setclip.cy);

-				break;

-		#endif

-		#if GDISP_NEED_CIRCLE

-			case GDISP_LLD_MSG_DRAWCIRCLE:

-				lld_gdisp_draw_circle(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color);

-				break;

-			case GDISP_LLD_MSG_FILLCIRCLE:

-				lld_gdisp_fill_circle(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color);

-				break;

-		#endif

-		#if GDISP_NEED_ELLIPSE

-			case GDISP_LLD_MSG_DRAWELLIPSE:

-				lld_gdisp_draw_ellipse(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color);

-				break;

-			case GDISP_LLD_MSG_FILLELLIPSE:

-				lld_gdisp_fill_ellipse(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color);

-				break;

-		#endif

-		#if GDISP_NEED_ARC

-			case GDISP_LLD_MSG_DRAWARC:

-				lld_gdisp_draw_circle(msg->drawarc.x, msg->drawarc.y, msg->drawarc.radius, msg->drawarc.startangle, msg->drawarc.endangle, msg->drawarc.color);

-				break;

-			case GDISP_LLD_MSG_FILLARC:

-				lld_gdisp_fill_circle(msg->fillarc.x, msg->fillarc.y, msg->fillarc.radius, msg->fillarc.startangle, msg->fillarc.endangle, msg->fillarc.color);

-				break;

-		#endif

-		#if GDISP_NEED_TEXT

-			case GDISP_LLD_MSG_DRAWCHAR:

-				lld_gdisp_draw_char(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color);

-				break;

-			case GDISP_LLD_MSG_FILLCHAR:

-				lld_gdisp_fill_char(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor);

-				break;

-		#endif

-		#if GDISP_NEED_PIXELREAD

-			case GDISP_LLD_MSG_GETPIXELCOLOR:

-				msg->getpixelcolor.result = lld_gdisp_get_pixel_color(msg->getpixelcolor.x, msg->getpixelcolor.y);

-				break;

-		#endif

-		#if GDISP_NEED_SCROLL

-			case GDISP_LLD_MSG_VERTICALSCROLL:

-				lld_gdisp_vertical_scroll(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor);

-				break;

-		#endif

-		#if GDISP_NEED_CONTROL

-			case GDISP_LLD_MSG_CONTROL:

-				lld_gdisp_control(msg->control.what, msg->control.value);

-				break;

-		#endif

-			case GDISP_LLD_MSG_QUERY:

-				msg->query.result = lld_gdisp_query(msg->query.what);

-				break;

-		}

-	}

-#endif

-

-#endif  /* GFX_USE_GDISP */

-#endif	/* GDISP_EMULATION_C */

-/** @} */

-

+/*
+    ChibiOS/GFX - Copyright (C) 2012
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file	include/gdisp/lld/emulation.c
+ * @brief	GDISP emulation routines for stuff the driver dosen't support
+ *
+ * @addtogroup GDISP
+ *
+ * @details	Even though this is a software emulation of a low level driver
+ *			most validation doesn't need to happen here as eventually
+ *			we call a real low level driver routine and if validation is
+ *			required - it will do it.
+ *
+ * @{
+ */
+#ifndef GDISP_EMULATION_C
+#define GDISP_EMULATION_C
+
+#if GFX_USE_GDISP /*|| defined(__DOXYGEN__) */
+
+#ifndef GDISP_LLD_NO_STRUCT
+	static struct GDISPDriver {
+		coord_t				Width;
+		coord_t				Height;
+		gdisp_orientation_t	Orientation;
+		gdisp_powermode_t	Powermode;
+		uint8_t				Backlight;
+		uint8_t				Contrast;
+		#if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION
+			coord_t				clipx0, clipy0;
+			coord_t				clipx1, clipy1;		/* not inclusive */
+		#endif
+		} GDISP;
+#endif
+
+#if !GDISP_HARDWARE_CLEARS 
+	void gdisp_lld_clear(color_t color) {
+		gdisp_lld_fill_area(0, 0, GDISP.Width, GDISP.Height, color);
+	}
+#endif
+
+#if !GDISP_HARDWARE_LINES 
+	void gdisp_lld_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+		int16_t dy, dx;
+		int16_t addx, addy;
+		int16_t P, diff, i;
+
+		#if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL
+		// speed improvement if vertical or horizontal
+		if (x0 == x1) {
+			if (y1 > y0)
+				gdisp_lld_fill_area(x0, y0, 1, y1-y0+1, color);
+			else
+				gdisp_lld_fill_area(x0, y1, 1, y0-y1+1, color);
+			return;
+		}
+		if (y0 == y1) {
+			if (x1 > x0)
+				gdisp_lld_fill_area(x0, y0, x1-x0+1, 1, color);
+			else
+				gdisp_lld_fill_area(x0, y1, x0-x1+1, 1, color);
+			return;
+		}
+		#endif
+
+		if (x1 >= x0) {
+			dx = x1 - x0;
+			addx = 1;
+		} else {
+			dx = x0 - x1;
+			addx = -1;
+		}
+		if (y1 >= y0) {
+			dy = y1 - y0;
+			addy = 1;
+		} else {
+			dy = y0 - y1;
+			addy = -1;
+		}
+
+		if (dx >= dy) {
+			dy *= 2;
+			P = dy - dx;
+			diff = P - dx;
+
+			for(i=0; i<=dx; ++i) {
+				gdisp_lld_draw_pixel(x0, y0, color);
+				if (P < 0) {
+					P  += dy;
+					x0 += addx;
+				} else {
+					P  += diff;
+					x0 += addx;
+					y0 += addy;
+				}
+			}
+		} else {
+			dx *= 2;
+			P = dx - dy;
+			diff = P - dy;
+
+			for(i=0; i<=dy; ++i) {
+				gdisp_lld_draw_pixel(x0, y0, color);
+				if (P < 0) {
+					P  += dx;
+					y0 += addy;
+				} else {
+					P  += diff;
+					x0 += addx;
+					y0 += addy;
+				}
+			}
+		}
+	}
+#endif
+
+#if !GDISP_HARDWARE_FILLS
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+		#if GDISP_HARDWARE_SCROLL
+			gdisp_lld_vertical_scroll(x, y, cx, cy, cy, color);
+		#elif GDISP_HARDWARE_LINES
+			coord_t x1, y1;
+			
+			x1 = x + cx - 1;
+			y1 = y + cy;
+			for(; y < y1; y++)
+				gdisp_lld_draw_line(x, y, x1, y, color);
+		#else
+			coord_t x0, x1, y1;
+			
+			x0 = x;
+			x1 = x + cx;
+			y1 = y + cy;
+			for(; y < y1; y++)
+				for(x = x0; x < x1; x++)
+					gdisp_lld_draw_pixel(x, y, color);
+		#endif
+	}
+#endif
+
+#if !GDISP_HARDWARE_BITFILLS
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+			coord_t x0, x1, y1;
+			
+			x0 = x;
+			x1 = x + cx;
+			y1 = y + cy;
+			buffer += srcy*srccx+srcx;
+			srccx -= cx;
+			for(; y < y1; y++, buffer += srccx)
+				for(x=x0; x < x1; x++)
+					gdisp_lld_draw_pixel(x, y, *buffer++);
+	}
+#endif
+
+#if GDISP_NEED_CLIP && !GDISP_HARDWARE_CLIP
+	void gdisp_lld_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
+		#if GDISP_NEED_VALIDATION
+			if (x >= GDISP.Width || y >= GDISP.Height || cx < 0 || cy < 0)
+				return;
+			if (x < 0) x = 0;
+			if (y < 0) y = 0;
+			if (x+cx > GDISP.Width) cx = GDISP.Width - x;
+			if (y+cy > GDISP.Height) cy = GDISP.Height - y;
+		#endif
+		GDISP.clipx0 = x;
+		GDISP.clipy0 = y;
+		GDISP.clipx1 = x+cx;
+		GDISP.clipy1 = y+cy;
+	}
+#endif
+
+#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES
+	void gdisp_lld_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
+		coord_t a, b, P;
+
+		a = 0;
+		b = radius;
+		P = 1 - radius;
+
+		do {
+			gdisp_lld_draw_pixel(x+a, y+b, color);
+			gdisp_lld_draw_pixel(x+b, y+a, color);
+			gdisp_lld_draw_pixel(x-a, y+b, color);
+			gdisp_lld_draw_pixel(x-b, y+a, color);
+			gdisp_lld_draw_pixel(x+b, y-a, color);
+			gdisp_lld_draw_pixel(x+a, y-b, color);
+			gdisp_lld_draw_pixel(x-a, y-b, color);
+			gdisp_lld_draw_pixel(x-b, y-a, color);
+			if (P < 0)
+				P += 3 + 2*a++;
+			else
+				P += 5 + 2*(a++ - b--);
+		} while(a <= b);
+	}
+#endif
+
+#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS
+	void gdisp_lld_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
+		coord_t a, b, P;
+		
+		a = 0;
+		b = radius;
+		P = 1 - radius;
+
+		do {
+			gdisp_lld_draw_line(x-a, y+b, x+a, y+b, color);
+			gdisp_lld_draw_line(x-a, y-b, x+a, y-b, color);
+			gdisp_lld_draw_line(x-b, y+a, x+b, y+a, color);
+			gdisp_lld_draw_line(x-b, y-a, x+b, y-a, color);
+			if (P < 0)
+				P += 3 + 2*a++;
+			else
+				P += 5 + 2*(a++ - b--);
+		} while(a <= b);
+	}
+#endif
+
+#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES
+	void gdisp_lld_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */
+		long a2 = a*a, b2 = b*b;
+		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */
+
+		do {
+			gdisp_lld_draw_pixel(x+dx, y+dy, color); /* I. Quadrant */
+			gdisp_lld_draw_pixel(x-dx, y+dy, color); /* II. Quadrant */
+			gdisp_lld_draw_pixel(x-dx, y-dy, color); /* III. Quadrant */
+			gdisp_lld_draw_pixel(x+dx, y-dy, color); /* IV. Quadrant */
+
+			e2 = 2*err;
+			if(e2 <  (2*dx+1)*b2) {
+				dx++;
+				err += (2*dx+1)*b2;
+			}
+			if(e2 > -(2*dy-1)*a2) {
+				dy--;
+				err -= (2*dy-1)*a2;
+			}
+		} while(dy >= 0); 
+
+		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
+			gdisp_lld_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
+			gdisp_lld_draw_pixel(x-dx, y, color);
+	   }   
+	}
+#endif
+
+#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS
+	void gdisp_lld_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */
+		long a2 = a*a, b2 = b*b;
+		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */
+
+		do {
+			gdisp_lld_draw_line(x-dx,y+dy,x+dx,y+dy, color);
+			gdisp_lld_draw_line(x-dx,y-dy,x+dx,y-dy, color);
+
+			e2 = 2*err;
+			if(e2 <  (2*dx+1)*b2) {
+				dx++;
+				err += (2*dx+1)*b2;
+			}
+			if(e2 > -(2*dy-1)*a2) {
+				dy--;
+				err -= (2*dy-1)*a2;
+			}
+		} while(dy >= 0); 
+
+		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
+			gdisp_lld_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
+			gdisp_lld_draw_pixel(x-dx, y, color);
+	   }   
+	}
+#endif
+
+#if GDISP_NEED_ARC && !GDISP_HARDWARE_ARCS
+
+	#include <math.h>
+
+	/*
+	 * @brief				Internal helper function for gdispDrawArc()
+	 *
+	 * @note				DO NOT USE DIRECTLY!
+	 *
+	 * @param[in] x, y		The middle point of the arc
+	 * @param[in] start		The start angle of the arc
+	 * @param[in] end		The end angle of the arc
+	 * @param[in] radius	The radius of the arc
+	 * @param[in] color		The color in which the arc will be drawn
+	 *
+	 * @notapi
+	 */
+	static void _draw_arc(coord_t x, coord_t y, uint16_t start, uint16_t end, uint16_t radius, color_t color) {
+	    if (/*start >= 0 && */start <= 180) {
+	        float x_maxI = x + radius*cos(start*M_PI/180);
+	        float x_minI;
+
+	        if (end > 180)
+	            x_minI = x - radius;
+	        else
+	            x_minI = x + radius*cos(end*M_PI/180);
+
+	        int a = 0;
+	        int b = radius;
+	        int P = 1 - radius;
+
+	        do {
+	            if(x-a <= x_maxI && x-a >= x_minI)
+	            	gdisp_lld_draw_pixel(x-a, y-b, color);
+	            if(x+a <= x_maxI && x+a >= x_minI)
+	            	gdisp_lld_draw_pixel(x+a, y-b, color);
+	            if(x-b <= x_maxI && x-b >= x_minI)
+	            	gdisp_lld_draw_pixel(x-b, y-a, color);
+	            if(x+b <= x_maxI && x+b >= x_minI)
+	            	gdisp_lld_draw_pixel(x+b, y-a, color);
+
+	            if (P < 0) {
+	                P = P + 3 + 2*a;
+	                a = a + 1;
+	            } else {
+	                P = P + 5 + 2*(a - b);
+	                a = a + 1;
+	                b = b - 1;
+	            }
+	        } while(a <= b);
+	    }
+
+	    if (end > 180 && end <= 360) {
+	        float x_maxII = x+radius*cos(end*M_PI/180);
+	        float x_minII;
+
+	        if(start <= 180)
+	            x_minII = x - radius;
+	        else
+	            x_minII = x+radius*cos(start*M_PI/180);
+
+	        int a = 0;
+	        int b = radius;
+	        int P = 1 - radius;
+
+	        do {
+	            if(x-a <= x_maxII && x-a >= x_minII)
+	            	gdisp_lld_draw_pixel(x-a, y+b, color);
+	            if(x+a <= x_maxII && x+a >= x_minII)
+	            	gdisp_lld_draw_pixel(x+a, y+b, color);
+	            if(x-b <= x_maxII && x-b >= x_minII)
+	            	gdisp_lld_draw_pixel(x-b, y+a, color);
+	            if(x+b <= x_maxII && x+b >= x_minII)
+	            	gdisp_lld_draw_pixel(x+b, y+a, color);
+
+	            if (P < 0) {
+	                P = P + 3 + 2*a;
+	                a = a + 1;
+	            } else {
+	                P = P + 5 + 2*(a - b);
+	                a = a + 1;
+	                b = b - 1;
+	            }
+	        } while (a <= b);
+	    }
+	}
+
+	void gdisp_lld_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
+		if(endangle < startangle) {
+	        _draw_arc(x, y, startangle, 360, radius, color);
+	        _draw_arc(x, y, 0, endangle, radius, color);
+	    } else {
+	        _draw_arc(x, y, startangle, endangle, radius, color);
+		}
+	}
+#endif
+
+#if GDISP_NEED_ARC && !GDISP_HARDWARE_ARCFILLS
+	/*
+	 * @brief				Internal helper function for gdispDrawArc()
+	 *
+	 * @note				DO NOT USE DIRECTLY!
+	 *
+	 * @param[in] x, y		The middle point of the arc
+	 * @param[in] start		The start angle of the arc
+	 * @param[in] end		The end angle of the arc
+	 * @param[in] radius	The radius of the arc
+	 * @param[in] color		The color in which the arc will be drawn
+	 *
+	 * @notapi
+	 */
+	static void _fill_arc(coord_t x, coord_t y, uint16_t start, uint16_t end, uint16_t radius, color_t color) {
+	    if (/*start >= 0 && */start <= 180) {
+	        float x_maxI = x + radius*cos(start*M_PI/180);
+	        float x_minI;
+
+	        if (end > 180)
+	            x_minI = x - radius;
+	        else
+	            x_minI = x + radius*cos(end*M_PI/180);
+
+	        int a = 0;
+	        int b = radius;
+	        int P = 1 - radius;
+
+	        do {
+	            if(x-a <= x_maxI && x-a >= x_minI)
+	            	gdisp_lld_draw_line(x, y, x-a, y-b, color);
+	            if(x+a <= x_maxI && x+a >= x_minI)
+	            	gdisp_lld_draw_line(x, y, x+a, y-b, color);
+	            if(x-b <= x_maxI && x-b >= x_minI)
+	            	gdisp_lld_draw_line(x, y, x-b, y-a, color);
+	            if(x+b <= x_maxI && x+b >= x_minI)
+	            	gdisp_lld_draw_line(x, y, x+b, y-a, color);
+
+	            if (P < 0) {
+	                P = P + 3 + 2*a;
+	                a = a + 1;
+	            } else {
+	                P = P + 5 + 2*(a - b);
+	                a = a + 1;
+	                b = b - 1;
+	            }
+	        } while(a <= b);
+	    }
+
+	    if (end > 180 && end <= 360) {
+	        float x_maxII = x+radius*cos(end*M_PI/180);
+	        float x_minII;
+
+	        if(start <= 180)
+	            x_minII = x - radius;
+	        else
+	            x_minII = x+radius*cos(start*M_PI/180);
+
+	        int a = 0;
+	        int b = radius;
+	        int P = 1 - radius;
+
+	        do {
+	            if(x-a <= x_maxII && x-a >= x_minII)
+	            	gdisp_lld_draw_line(x, y, x-a, y+b, color);
+	            if(x+a <= x_maxII && x+a >= x_minII)
+	            	gdisp_lld_draw_line(x, y, x+a, y+b, color);
+	            if(x-b <= x_maxII && x-b >= x_minII)
+	            	gdisp_lld_draw_line(x, y, x-b, y+a, color);
+	            if(x+b <= x_maxII && x+b >= x_minII)
+	            	gdisp_lld_draw_line(x, y, x+b, y+a, color);
+
+	            if (P < 0) {
+	                P = P + 3 + 2*a;
+	                a = a + 1;
+	            } else {
+	                P = P + 5 + 2*(a - b);
+	                a = a + 1;
+	                b = b - 1;
+	            }
+	        } while (a <= b);
+	    }
+	}
+
+	void gdisp_lld_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
+		if(endangle < startangle) {
+	        _fill_arc(x, y, startangle, 360, radius, color);
+	        _fill_arc(x, y, 0, endangle, radius, color);
+	    } else {
+	        _fill_arc(x, y, startangle, endangle, radius, color);
+		}
+	}
+#endif
+
+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT
+	#include "gdisp/fonts.h"
+#endif
+
+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT
+	void gdisp_lld_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color) {
+		const fontcolumn_t	*ptr;
+		fontcolumn_t		column;
+		coord_t				width, height, xscale, yscale;
+		coord_t				i, j, xs, ys;
+
+		/* Check we actually have something to print */
+		width = _getCharWidth(font, c);
+		if (!width) return;
+		
+		xscale = font->xscale;
+		yscale = font->yscale;
+		height = font->height * yscale;
+		width *= xscale;
+
+		ptr = _getCharData(font, c);
+
+		/* Loop through the data and display. The font data is LSBit first, down the column */
+		for(i=0; i < width; i+=xscale) {
+			/* Get the font bitmap data for the column */
+			column = *ptr++;
+			
+			/* Draw each pixel */
+			for(j=0; j < height; j+=yscale, column >>= 1) {
+				if (column & 0x01) {
+					for(xs=0; xs < xscale; xs++)
+						for(ys=0; ys < yscale; ys++)
+							gdisp_lld_draw_pixel(x+i+xs, y+j+ys, color);
+				}
+			}
+		}
+	}
+#endif
+
+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS
+	void gdisp_lld_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
+		coord_t			width, height;
+		coord_t			xscale, yscale;
+		
+		/* Check we actually have something to print */
+		width = _getCharWidth(font, c);
+		if (!width) return;
+
+		xscale = font->xscale;
+		yscale = font->yscale;
+		height = font->height * yscale;
+		width *= xscale;
+
+		/* Method 1: Use background fill and then draw the text */
+		#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW
+			
+			/* Fill the area */
+			gdisp_lld_fill_area(x, y, width, height, bgcolor);
+			
+			/* Draw the text */
+			gdisp_lld_draw_char(x, y, c, font, color);
+
+		/* Method 2: Create a single column bitmap and then blit it */
+		#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN
+		{
+			const fontcolumn_t	*ptr;
+			fontcolumn_t		column;
+			coord_t				i, j, xs, ys;
+
+			/* Working buffer for fast non-transparent text rendering [patch by Badger]
+				This needs to be larger than the largest character we can print.
+				Assume the max is double sized by one column.
+			*/
+			static pixel_t		buf[sizeof(fontcolumn_t)*8*2];
+
+			#if GDISP_NEED_VALIDATION
+				/* Check our buffer is big enough */
+				if ((unsigned)height > sizeof(buf)/sizeof(buf[0]))	return;
+			#endif
+
+			ptr = _getCharData(font, c);
+
+			/* Loop through the data and display. The font data is LSBit first, down the column */
+			for(i = 0; i < width; i+=xscale) {
+				/* Get the font bitmap data for the column */
+				column = *ptr++;
+				
+				/* Draw each pixel */
+				for(j = 0; j < height; j+=yscale, column >>= 1) {
+					if (column & 0x01) {
+						for(ys=0; ys < yscale; ys++)
+							gdispPackPixels(buf, 1, j+ys, 0, color);
+					} else {
+						for(ys=0; ys < yscale; ys++)
+							gdispPackPixels(buf, 1, j+ys, 0, bgcolor);
+					}
+				}
+
+				for(xs=0; xs < xscale; xs++)
+					gdisp_lld_blit_area_ex(x+i+xs, y, 1, height, 0, 0, 1, buf);
+			}
+		}
+
+		/* Method 3: Create a character bitmap and then blit it */
+		#elif GDISP_HARDWARE_BITFILLS
+		{
+			const fontcolumn_t	*ptr;
+			fontcolumn_t		column;
+			coord_t				i, j, xs, ys;
+			
+			/* Working buffer for fast non-transparent text rendering [patch by Badger]
+				This needs to be larger than the largest character we can print.
+				Assume the max is double sized.
+			*/
+			static pixel_t		buf[20*(sizeof(fontcolumn_t)*8)*2];
+
+			#if GDISP_NEED_VALIDATION
+				/* Check our buffer is big enough */
+				if ((unsigned)(width * height) > sizeof(buf)/sizeof(buf[0]))	return;
+			#endif
+
+			ptr = _getCharData(font, c);
+
+			/* Loop through the data and display. The font data is LSBit first, down the column */
+			for(i = 0; i < width; i+=xscale) {
+				/* Get the font bitmap data for the column */
+				column = *ptr++;
+				
+				/* Draw each pixel */
+				for(j = 0; j < height; j+=yscale, column >>= 1) {
+					if (column & 0x01) {
+						for(xs=0; xs < xscale; xs++)
+							for(ys=0; ys < yscale; ys++)
+								gdispPackPixels(buf, width, i+xs, j+ys, color);
+					} else {
+						for(xs=0; xs < xscale; xs++)
+							for(ys=0; ys < yscale; ys++)
+								gdispPackPixels(buf, width, i+xs, j+ys, bgcolor);
+					}
+				}
+			}
+
+			/* [Patch by Badger] Write all in one stroke */
+			gdisp_lld_blit_area_ex(x, y, width, height, 0, 0, width, buf);
+		}
+
+		/* Method 4: Draw pixel by pixel */
+		#else
+		{
+			const fontcolumn_t	*ptr;
+			fontcolumn_t		column;
+			coord_t				i, j, xs, ys;
+
+			ptr = _getCharData(font, c);
+
+			/* Loop through the data and display. The font data is LSBit first, down the column */
+			for(i = 0; i < width; i+=xscale) {
+				/* Get the font bitmap data for the column */
+				column = *ptr++;
+				
+				/* Draw each pixel */
+				for(j = 0; j < height; j+=yscale, column >>= 1) {
+					if (column & 0x01) {
+						for(xs=0; xs < xscale; xs++)
+							for(ys=0; ys < yscale; ys++)
+								gdisp_lld_draw_pixel(x+i+xs, y+j+ys, color);
+					} else {
+						for(xs=0; xs < xscale; xs++)
+							for(ys=0; ys < yscale; ys++)
+								gdisp_lld_draw_pixel(x+i+xs, y+j+ys, bgcolor);
+					}
+				}
+			}
+		}
+		#endif
+	}
+#endif
+
+
+#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL
+	void gdisp_lld_control(unsigned what, void *value) {
+		(void)what;
+		(void)value;
+		/* Ignore everything */
+	}
+#endif
+
+#if !GDISP_HARDWARE_QUERY
+void *gdisp_lld_query(unsigned what) {
+	switch(what) {
+	case GDISP_QUERY_WIDTH:			return (void *)(unsigned)GDISP.Width;
+	case GDISP_QUERY_HEIGHT:		return (void *)(unsigned)GDISP.Height;
+	case GDISP_QUERY_POWER:			return (void *)(unsigned)GDISP.Powermode;
+	case GDISP_QUERY_ORIENTATION:	return (void *)(unsigned)GDISP.Orientation;
+	case GDISP_QUERY_BACKLIGHT:		return (void *)(unsigned)GDISP.Backlight;
+	case GDISP_QUERY_CONTRAST:		return (void *)(unsigned)GDISP.Contrast;
+	default:						return (void *)-1;
+	}
+}
+#endif
+
+#if GDISP_NEED_MSGAPI
+	void gdisp_lld_msg_dispatch(gdisp_lld_msg_t *msg) {
+		switch(msg->action) {
+		case GDISP_LLD_MSG_NOP:
+			break;
+		case GDISP_LLD_MSG_INIT:
+			gdisp_lld_init();
+			break;
+		case GDISP_LLD_MSG_CLEAR:
+			gdisp_lld_clear(msg->clear.color);
+			break;
+		case GDISP_LLD_MSG_DRAWPIXEL:
+			gdisp_lld_draw_pixel(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color);
+			break;
+		case GDISP_LLD_MSG_FILLAREA:
+			gdisp_lld_fill_area(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color);
+			break;
+		case GDISP_LLD_MSG_BLITAREA:
+			gdisp_lld_blit_area_ex(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.srcx, msg->blitarea.srcy, msg->blitarea.srccx, msg->blitarea.buffer);
+			break;
+		case GDISP_LLD_MSG_DRAWLINE:
+			gdisp_lld_draw_line(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color);
+			break;
+		#if GDISP_NEED_CLIP
+			case GDISP_LLD_MSG_SETCLIP:
+				gdisp_lld_set_clip(msg->setclip.x, msg->setclip.y, msg->setclip.cx, msg->setclip.cy);
+				break;
+		#endif
+		#if GDISP_NEED_CIRCLE
+			case GDISP_LLD_MSG_DRAWCIRCLE:
+				gdisp_lld_draw_circle(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color);
+				break;
+			case GDISP_LLD_MSG_FILLCIRCLE:
+				gdisp_lld_fill_circle(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color);
+				break;
+		#endif
+		#if GDISP_NEED_ELLIPSE
+			case GDISP_LLD_MSG_DRAWELLIPSE:
+				gdisp_lld_draw_ellipse(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color);
+				break;
+			case GDISP_LLD_MSG_FILLELLIPSE:
+				gdisp_lld_fill_ellipse(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color);
+				break;
+		#endif
+		#if GDISP_NEED_ARC
+			case GDISP_LLD_MSG_DRAWARC:
+				gdisp_lld_draw_circle(msg->drawarc.x, msg->drawarc.y, msg->drawarc.radius, msg->drawarc.startangle, msg->drawarc.endangle, msg->drawarc.color);
+				break;
+			case GDISP_LLD_MSG_FILLARC:
+				gdisp_lld_fill_circle(msg->fillarc.x, msg->fillarc.y, msg->fillarc.radius, msg->fillarc.startangle, msg->fillarc.endangle, msg->fillarc.color);
+				break;
+		#endif
+		#if GDISP_NEED_TEXT
+			case GDISP_LLD_MSG_DRAWCHAR:
+				gdisp_lld_draw_char(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color);
+				break;
+			case GDISP_LLD_MSG_FILLCHAR:
+				gdisp_lld_fill_char(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor);
+				break;
+		#endif
+		#if GDISP_NEED_PIXELREAD
+			case GDISP_LLD_MSG_GETPIXELCOLOR:
+				msg->getpixelcolor.result = gdisp_lld_get_pixel_color(msg->getpixelcolor.x, msg->getpixelcolor.y);
+				break;
+		#endif
+		#if GDISP_NEED_SCROLL
+			case GDISP_LLD_MSG_VERTICALSCROLL:
+				gdisp_lld_vertical_scroll(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor);
+				break;
+		#endif
+		#if GDISP_NEED_CONTROL
+			case GDISP_LLD_MSG_CONTROL:
+				gdisp_lld_control(msg->control.what, msg->control.value);
+				break;
+		#endif
+			case GDISP_LLD_MSG_QUERY:
+				msg->query.result = gdisp_lld_query(msg->query.what);
+				break;
+		}
+	}
+#endif
+
+#endif  /* GFX_USE_GDISP */
+#endif	/* GDISP_EMULATION_C */
+/** @} */
+
diff --git a/include/gdisp/lld/gdisp_lld.h b/include/gdisp/lld/gdisp_lld.h
index da1b29c6..04a0dcf4 100644
--- a/include/gdisp/lld/gdisp_lld.h
+++ b/include/gdisp/lld/gdisp_lld.h
@@ -1,539 +1,539 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    ChibiOS/GFX is free software; you can redistribute it and/or modify

-    it under the terms of the GNU General Public License as published by

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file    include/gdisp/lld/lld_gdisp.h

- * @brief   GDISP Graphic Driver subsystem low level driver header.

- *

- * @addtogroup GDISP

- * @{

- */

-

-#ifndef _GDISP_LLD_H

-#define _GDISP_LLD_H

-

-#if GFX_USE_GDISP || defined(__DOXYGEN__)

-

-/*===========================================================================*/

-/* Low level driver configuration needs					                     */

-/*===========================================================================*/

-

-/*===========================================================================*/

-/* Include the low level driver configuration information                    */

-/*===========================================================================*/

-

-#include "gdisp_lld_config.h"

-

-/*===========================================================================*/

-/* Constants.                                                                */

-/*===========================================================================*/

-

-/**

- * @brief   Driver Control Constants

- * @details	Unsupported control codes are ignored.

- * @note	The value parameter should always be typecast to (void *).

- * @note	There are some predefined and some specific to the low level driver.

- * @note	GDISP_CONTROL_POWER			- Takes a gdisp_powermode_t

- * 			GDISP_CONTROL_ORIENTATION	- Takes a gdisp_orientation_t

- * 			GDISP_CONTROL_BACKLIGHT -	 Takes an int from 0 to 100. For a driver

- * 											that only supports off/on anything other

- * 											than zero is on.

- * 			GDISP_CONTROL_CONTRAST		- Takes an int from 0 to 100.

- * 			GDISP_CONTROL_LLD			- Low level driver control constants start at

- * 											this value.

- */

-#define GDISP_CONTROL_POWER			0

-#define GDISP_CONTROL_ORIENTATION	1

-#define GDISP_CONTROL_BACKLIGHT		2

-#define GDISP_CONTROL_CONTRAST		3

-#define GDISP_CONTROL_LLD			1000

-

-/**

- * @brief   Driver Query Constants

- * @details	Unsupported query codes return (void *)-1.

- * @note	There are some predefined and some specific to the low level driver.

- * @note	The result should be typecast the required type.

- * @note	GDISP_QUERY_WIDTH			- Gets the width of the screen

- * 			GDISP_QUERY_HEIGHT			- Gets the height of the screen

- * 			GDISP_QUERY_POWER			- Get the current powermode

- * 			GDISP_QUERY_ORIENTATION		- Get the current orientation

- * 			GDISP_QUERY_BACKLIGHT		- Get the backlight state (0 to 100)

- * 			GDISP_QUERY_CONTRAST		- Get the contrast.

- * 			GDISP_QUERY_LLD				- Low level driver control constants start at

- * 											this value.

- */

-#define GDISP_QUERY_WIDTH			0

-#define GDISP_QUERY_HEIGHT			1

-#define GDISP_QUERY_POWER			2

-#define GDISP_QUERY_ORIENTATION		3

-#define GDISP_QUERY_BACKLIGHT		4

-#define GDISP_QUERY_CONTRAST		5

-#define GDISP_QUERY_LLD				1000

-

-/**

- * @brief   Driver Pixel Format Constants

- */

-#define GDISP_PIXELFORMAT_RGB565	565

-#define GDISP_PIXELFORMAT_RGB888	888

-#define GDISP_PIXELFORMAT_RGB444	444

-#define GDISP_PIXELFORMAT_RGB332	332

-#define GDISP_PIXELFORMAT_RGB666	666

-#define GDISP_PIXELFORMAT_CUSTOM	99999

-#define GDISP_PIXELFORMAT_ERROR		88888

-

-/*===========================================================================*/

-/* Error checks.                                                             */

-/*===========================================================================*/

-

-/**

- * @name    GDISP hardware accelerated support

- * @{

- */

-	/**

-	 * @brief   Hardware accelerated line drawing.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_LINES

-		#define GDISP_HARDWARE_LINES			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated screen clears.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_CLEARS

-		#define GDISP_HARDWARE_CLEARS			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated rectangular fills.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_FILLS

-		#define GDISP_HARDWARE_FILLS			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated fills from an image.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_BITFILLS

-		#define GDISP_HARDWARE_BITFILLS			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated circles.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_CIRCLES

-		#define GDISP_HARDWARE_CIRCLES			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated filled circles.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_CIRCLEFILLS

-		#define GDISP_HARDWARE_CIRCLEFILLS		FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated ellipses.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_ELLIPSES

-		#define GDISP_HARDWARE_ELLIPSES			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated filled ellipses.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_ELLIPSEFILLS

-		#define GDISP_HARDWARE_ELLIPSEFILLS		FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated arc's.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_ARCS

-		#define GDISP_HARDWARE_ARCS			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated filled arcs.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_ARCFILLS

-		#define GDISP_HARDWARE_ARCFILLS		FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated text drawing.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_TEXT

-		#define GDISP_HARDWARE_TEXT				FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated text drawing with a filled background.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_TEXTFILLS

-		#define GDISP_HARDWARE_TEXTFILLS		FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated scrolling.

-	 * @details If set to @p FALSE there is no support for scrolling.

-	 */

-	#ifndef GDISP_HARDWARE_SCROLL

-		#define GDISP_HARDWARE_SCROLL			FALSE

-	#endif

-

-	/**

-	 * @brief   Reading back of pixel values.

-	 * @details If set to @p FALSE there is no support for pixel read-back.

-	 */

-	#ifndef GDISP_HARDWARE_PIXELREAD

-		#define GDISP_HARDWARE_PIXELREAD		FALSE

-	#endif

-

-	/**

-	 * @brief   The driver supports one or more control commands.

-	 * @details If set to @p FALSE there is no support for control commands.

-	 */

-	#ifndef GDISP_HARDWARE_CONTROL

-		#define GDISP_HARDWARE_CONTROL			FALSE

-	#endif

-

-	/**

-	 * @brief   The driver supports a non-standard query.

-	 * @details If set to @p FALSE there is no support for non-standard queries.

-	 */

-	#ifndef GDISP_HARDWARE_QUERY

-		#define GDISP_HARDWARE_QUERY			FALSE

-	#endif

-

-	/**

-	 * @brief   The driver supports a clipping in hardware.

-	 * @details If set to @p FALSE there is no support for non-standard queries.

-	 */

-	#ifndef GDISP_HARDWARE_CLIP

-		#define GDISP_HARDWARE_CLIP			FALSE

-	#endif

-/** @} */

-

-/**

- * @name    GDISP software algorithm choices

- * @{

- */

-	/**

-	 * @brief   For filled text drawing, use a background fill and then draw

-	 *			the text instead of using a blit or direct pixel drawing.

-	 * @details If set to @p TRUE background fill and then text draw is used.

-	 * @note    This is ignored if hardware accelerated text is supported.

-	 */

-	#ifndef GDISP_SOFTWARE_TEXTFILLDRAW

-		#define GDISP_SOFTWARE_TEXTFILLDRAW		FALSE

-	#endif

-

-	/**

-	 * @brief   For filled text drawing, when using a bitmap blit

-	 *			use a column by column buffer rather than a full character

-	 *			buffer to save memory at a small performance cost.

-	 * @details If set to @p TRUE background fill one character column at a time.

-	 * @note    This is ignored if software text using blit is not being used.

-	 */

-	#ifndef GDISP_SOFTWARE_TEXTBLITCOLUMN

-		#define GDISP_SOFTWARE_TEXTBLITCOLUMN	FALSE

-	#endif

-/** @} */

-

-/**

- * @name    GDISP pixel format choices

- * @{

- */

-	/**

-	 * @brief   The native pixel format for this device

-	 * @note	Should be set to one of the following:

-	 *				GDISP_PIXELFORMAT_RGB565

-	 *				GDISP_PIXELFORMAT_RGB888

-	 *				GDISP_PIXELFORMAT_RGB444

-	 *				GDISP_PIXELFORMAT_RGB332

-	 *				GDISP_PIXELFORMAT_RGB666

-	 *				GDISP_PIXELFORMAT_CUSTOM

-	 * @note	If you set GDISP_PIXELFORMAT_CUSTOM you need to also define

-	 *				color_t, RGB2COLOR(r,g,b), HTML2COLOR(h),

-	 *              RED_OF(c), GREEN_OF(c), BLUE_OF(c),

-	 *              COLOR(c) and MASKCOLOR.

-	 */

-	#ifndef GDISP_PIXELFORMAT

-		#define GDISP_PIXELFORMAT	GDISP_PIXELFORMAT_ERROR

-	#endif

-

-	/**

-	 * @brief   Do pixels require packing for a blit

-	 * @note	Is only valid for a pixel format that doesn't fill it's datatype. ie formats:

-	 *				GDISP_PIXELFORMAT_RGB888

-	 *				GDISP_PIXELFORMAT_RGB444

-	 *				GDISP_PIXELFORMAT_RGB666

-	 *				GDISP_PIXELFORMAT_CUSTOM

-	 * @note	If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills

-	 *				you need to also define @p gdispPackPixels(buf,cx,x,y,c)

-	 * @note	If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel

-	 *				format must not be a packed format as the software blit does

-	 *				not support packed pixels

-	 * @note	Very few cases should actually require packed pixels as the low

-	 *				level driver can also pack on the fly as it is sending it

-	 *				to the graphics device.

-	 */

-	#ifndef GDISP_PACKED_PIXELS

-		#define GDISP_PACKED_PIXELS			FALSE

-	#endif

-

-	/**

-	 * @brief   Do lines of pixels require packing for a blit

-	 * @note	Ignored if GDISP_PACKED_PIXELS is FALSE

-	 */

-	#ifndef GDISP_PACKED_LINES

-		#define GDISP_PACKED_LINES			FALSE

-	#endif

-/** @} */

-

-/*===========================================================================*/

-/* Define the macro's for the various pixel formats */

-/*===========================================================================*/

-

-#if defined(__DOXYGEN__)

-	/**

-	 * @brief   The color of a pixel.

-	 */

-	typedef uint16_t color_t;

-	/**

-	 * @brief   Convert a number (of any type) to a color_t.

-	 * @details Masks any invalid bits in the color

-	 */

-	#define COLOR(c)			((color_t)(c))

-	/**

-	 * @brief   Does the color_t type contain invalid bits that need masking.

-	 */

-	#define MASKCOLOR			FALSE

-	/**

-	 * @brief   Convert red, green, blue (each 0 to 255) into a color value.

-	 */

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))

-	/**

-	 * @brief   Convert a 6 digit HTML code (hex) into a color value.

-	 */

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))

-	/**

-	 * @brief   Extract the red component (0 to 255) of a color value.

-	 */

-	#define RED_OF(c)			(((c) & 0xF800)>>8)

-	/**

-	 * @brief   Extract the green component (0 to 255) of a color value.

-	 */

-	#define GREEN_OF(c)			(((c)&0x007E)>>3)

-	/**

-	 * @brief   Extract the blue component (0 to 255) of a color value.

-	 */

-	#define BLUE_OF(c)			(((c)&0x001F)<<3)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565

-	typedef uint16_t color_t;

-	#define COLOR(c)			((color_t)(c))

-	#define MASKCOLOR			FALSE

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))

-	#define RED_OF(c)			(((c) & 0xF800)>>8)

-	#define GREEN_OF(c)			(((c)&0x07E0)>>3)

-	#define BLUE_OF(c)			(((c)&0x001F)<<3)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888

-	typedef uint32_t color_t;

-	#define COLOR(c)			((color_t)(((c) & 0xFFFFFF)))

-	#define MASKCOLOR			TRUE

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xFF)<<16) | (((g) & 0xFF) << 8) | ((b) & 0xFF)))

-	#define HTML2COLOR(h)		((color_t)(h))

-	#define RED_OF(c)			(((c) & 0xFF0000)>>16)

-	#define GREEN_OF(c)			(((c)&0x00FF00)>>8)

-	#define BLUE_OF(c)			((c)&0x0000FF)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB444

-	typedef uint16_t color_t;

-	#define COLOR(c)			((color_t)(((c) & 0x0FFF)))

-	#define MASKCOLOR			TRUE

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF0)<<4) | ((g) & 0xF0) | (((b) & 0xF0)>>4)))

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xF00000)>>12) | (((h) & 0x00F000)>>8) | (((h) & 0x0000F0)>>4)))

-	#define RED_OF(c)			(((c) & 0x0F00)>>4)

-	#define GREEN_OF(c)			((c)&0x00F0)

-	#define BLUE_OF(c)			(((c)&0x000F)<<4)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB332

-	typedef uint8_t color_t;

-	#define COLOR(c)			((color_t)(c))

-	#define MASKCOLOR			FALSE

-	#define RGB2COLOR(r,g,b)	((color_t)(((r) & 0xE0) | (((g) & 0xE0)>>3) | (((b) & 0xC0)>>6)))

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xE00000)>>16) | (((h) & 0x00E000)>>11) | (((h) & 0x0000C0)>>6)))

-	#define RED_OF(c)			((c) & 0xE0)

-	#define GREEN_OF(c)			(((c)&0x1C)<<3)

-	#define BLUE_OF(c)			(((c)&0x03)<<6)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB666

-	typedef uint32_t color_t;

-	#define COLOR(c)			((color_t)(((c) & 0x03FFFF)))

-	#define MASKCOLOR			TRUE

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xFC)<<10) | (((g) & 0xFC)<<4) | (((b) & 0xFC)>>2)))

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xFC0000)>>6) | (((h) & 0x00FC00)>>4) | (((h) & 0x0000FC)>>2)))

-	#define RED_OF(c)			(((c) & 0x03F000)>>12)

-	#define GREEN_OF(c)			(((c)&0x00FC00)>>8)

-	#define BLUE_OF(c)			(((c)&0x00003F)<<2)

-

-#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM

-	#error "GDISP: No supported pixel format has been specified."

-#endif

-

-/* Verify information for packed pixels and define a non-packed pixel macro */

-#if !GDISP_PACKED_PIXELS

-	#define gdispPackPixels(buf,cx,x,y,c)	{ ((color_t *)(buf))[(y)*(cx)+(x)] = (c); }

-#elif !GDISP_HARDWARE_BITFILLS

-	#error "GDISP: packed pixel formats are only supported for hardware accelerated drivers."

-#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888 \

-		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB444 \

-		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB666 \

-		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM

-	#error "GDISP: A packed pixel format has been specified for an unsupported pixel format."

-#endif

-

-#if GDISP_NEED_SCROLL && !GDISP_HARDWARE_SCROLL

-	#error "GDISP: Hardware scrolling is wanted but not supported."

-#endif

-

-#if GDISP_NEED_PIXELREAD && !GDISP_HARDWARE_PIXELREAD

-	#error "GDISP: Pixel read-back is wanted but not supported."

-#endif

-

-/*===========================================================================*/

-/* Driver types.                                                             */

-/*===========================================================================*/

-

-/**

- * @brief   The type of a pixel.

- */

-typedef color_t		pixel_t;

-/**

- * @brief   The type of a font.

- */

-typedef const struct font *font_t;

-/**

- * @brief   Type for the screen orientation.

- */

-typedef enum orientation {GDISP_ROTATE_0, GDISP_ROTATE_90, GDISP_ROTATE_180, GDISP_ROTATE_270} gdisp_orientation_t;

-/**

- * @brief   Type for the available power modes for the screen.

- */

-typedef enum powermode {powerOff, powerSleep, powerDeepSleep, powerOn} gdisp_powermode_t;

-

-/*===========================================================================*/

-/* External declarations.                                                    */

-/*===========================================================================*/

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-	/* Core functions */

-	extern bool_t lld_gdisp_init(void);

-

-	/* Some of these functions will be implemented in software by the high level driver

-	   depending on the GDISP_HARDWARE_XXX macros defined in lld_gdisp_config.h.

-	 */

-

-	/* Drawing functions */

-	extern void lld_gdisp_clear(color_t color);

-	extern void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color);

-	extern void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

-	extern void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);

-	extern void lld_gdisp_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);

-

-	/* Circular Drawing Functions */

-	#if GDISP_NEED_CIRCLE

-	extern void lld_gdisp_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color);

-	extern void lld_gdisp_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color);

-	#endif

-

-	#if GDISP_NEED_ELLIPSE

-	extern void lld_gdisp_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

-	extern void lld_gdisp_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

-	#endif

-

-	/* Arc Drawing Functions */

-	#if GDISP_NEED_ARC

-	extern void lld_gdisp_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);

-	extern void lld_gdisp_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);

-	#endif

-

-	/* Text Rendering Functions */

-	#if GDISP_NEED_TEXT

-	extern void lld_gdisp_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color);

-	extern void lld_gdisp_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);

-	#endif

-

-	/* Pixel readback */

-	#if GDISP_NEED_PIXELREAD

-	extern color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y);

-	#endif

-

-	/* Scrolling Function - clears the area scrolled out */

-	#if GDISP_NEED_SCROLL

-	extern void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);

-	#endif

-

-	/* Set driver specific control */

-	#if GDISP_NEED_CONTROL

-	extern void lld_gdisp_control(unsigned what, void *value);

-	#endif

-

-	/* Query driver specific data */

-	extern void *lld_gdisp_query(unsigned what);

-

-	/* Clipping Functions */

-	#if GDISP_NEED_CLIP

-	extern void lld_gdisp_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy);

-	#endif

-

-	/* Messaging API */

-	#if GDISP_NEED_MSGAPI

-	#include "lld_gdisp_msgs.h"

-	extern void lld_gdisp_msg_dispatch(lld_gdisp_msg_t *msg);

-	#endif

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif	/* GFX_USE_GDISP */

-

-#endif	/* _GDISP_LLD_H */

-/** @} */

-

+/*
+    ChibiOS/GFX - Copyright (C) 2012
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    include/gdisp/lld/gdisp_lld.h
+ * @brief   GDISP Graphic Driver subsystem low level driver header.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#ifndef _GDISP_LLD_H
+#define _GDISP_LLD_H
+
+#if GFX_USE_GDISP || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Low level driver configuration needs					                     */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Include the low level driver configuration information                    */
+/*===========================================================================*/
+
+#include "gdisp_lld_config.h"
+
+/*===========================================================================*/
+/* Constants.                                                                */
+/*===========================================================================*/
+
+/**
+ * @brief   Driver Control Constants
+ * @details	Unsupported control codes are ignored.
+ * @note	The value parameter should always be typecast to (void *).
+ * @note	There are some predefined and some specific to the low level driver.
+ * @note	GDISP_CONTROL_POWER			- Takes a gdisp_powermode_t
+ * 			GDISP_CONTROL_ORIENTATION	- Takes a gdisp_orientation_t
+ * 			GDISP_CONTROL_BACKLIGHT -	 Takes an int from 0 to 100. For a driver
+ * 											that only supports off/on anything other
+ * 											than zero is on.
+ * 			GDISP_CONTROL_CONTRAST		- Takes an int from 0 to 100.
+ * 			GDISP_CONTROL_LLD			- Low level driver control constants start at
+ * 											this value.
+ */
+#define GDISP_CONTROL_POWER			0
+#define GDISP_CONTROL_ORIENTATION	1
+#define GDISP_CONTROL_BACKLIGHT		2
+#define GDISP_CONTROL_CONTRAST		3
+#define GDISP_CONTROL_LLD			1000
+
+/**
+ * @brief   Driver Query Constants
+ * @details	Unsupported query codes return (void *)-1.
+ * @note	There are some predefined and some specific to the low level driver.
+ * @note	The result should be typecast the required type.
+ * @note	GDISP_QUERY_WIDTH			- Gets the width of the screen
+ * 			GDISP_QUERY_HEIGHT			- Gets the height of the screen
+ * 			GDISP_QUERY_POWER			- Get the current powermode
+ * 			GDISP_QUERY_ORIENTATION		- Get the current orientation
+ * 			GDISP_QUERY_BACKLIGHT		- Get the backlight state (0 to 100)
+ * 			GDISP_QUERY_CONTRAST		- Get the contrast.
+ * 			GDISP_QUERY_LLD				- Low level driver control constants start at
+ * 											this value.
+ */
+#define GDISP_QUERY_WIDTH			0
+#define GDISP_QUERY_HEIGHT			1
+#define GDISP_QUERY_POWER			2
+#define GDISP_QUERY_ORIENTATION		3
+#define GDISP_QUERY_BACKLIGHT		4
+#define GDISP_QUERY_CONTRAST		5
+#define GDISP_QUERY_LLD				1000
+
+/**
+ * @brief   Driver Pixel Format Constants
+ */
+#define GDISP_PIXELFORMAT_RGB565	565
+#define GDISP_PIXELFORMAT_RGB888	888
+#define GDISP_PIXELFORMAT_RGB444	444
+#define GDISP_PIXELFORMAT_RGB332	332
+#define GDISP_PIXELFORMAT_RGB666	666
+#define GDISP_PIXELFORMAT_CUSTOM	99999
+#define GDISP_PIXELFORMAT_ERROR		88888
+
+/*===========================================================================*/
+/* Error checks.                                                             */
+/*===========================================================================*/
+
+/**
+ * @name    GDISP hardware accelerated support
+ * @{
+ */
+	/**
+	 * @brief   Hardware accelerated line drawing.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_LINES
+		#define GDISP_HARDWARE_LINES			FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated screen clears.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_CLEARS
+		#define GDISP_HARDWARE_CLEARS			FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated rectangular fills.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_FILLS
+		#define GDISP_HARDWARE_FILLS			FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated fills from an image.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_BITFILLS
+		#define GDISP_HARDWARE_BITFILLS			FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated circles.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_CIRCLES
+		#define GDISP_HARDWARE_CIRCLES			FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated filled circles.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_CIRCLEFILLS
+		#define GDISP_HARDWARE_CIRCLEFILLS		FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated ellipses.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_ELLIPSES
+		#define GDISP_HARDWARE_ELLIPSES			FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated filled ellipses.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_ELLIPSEFILLS
+		#define GDISP_HARDWARE_ELLIPSEFILLS		FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated arc's.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_ARCS
+		#define GDISP_HARDWARE_ARCS			FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated filled arcs.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_ARCFILLS
+		#define GDISP_HARDWARE_ARCFILLS		FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated text drawing.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_TEXT
+		#define GDISP_HARDWARE_TEXT				FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated text drawing with a filled background.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#ifndef GDISP_HARDWARE_TEXTFILLS
+		#define GDISP_HARDWARE_TEXTFILLS		FALSE
+	#endif
+
+	/**
+	 * @brief   Hardware accelerated scrolling.
+	 * @details If set to @p FALSE there is no support for scrolling.
+	 */
+	#ifndef GDISP_HARDWARE_SCROLL
+		#define GDISP_HARDWARE_SCROLL			FALSE
+	#endif
+
+	/**
+	 * @brief   Reading back of pixel values.
+	 * @details If set to @p FALSE there is no support for pixel read-back.
+	 */
+	#ifndef GDISP_HARDWARE_PIXELREAD
+		#define GDISP_HARDWARE_PIXELREAD		FALSE
+	#endif
+
+	/**
+	 * @brief   The driver supports one or more control commands.
+	 * @details If set to @p FALSE there is no support for control commands.
+	 */
+	#ifndef GDISP_HARDWARE_CONTROL
+		#define GDISP_HARDWARE_CONTROL			FALSE
+	#endif
+
+	/**
+	 * @brief   The driver supports a non-standard query.
+	 * @details If set to @p FALSE there is no support for non-standard queries.
+	 */
+	#ifndef GDISP_HARDWARE_QUERY
+		#define GDISP_HARDWARE_QUERY			FALSE
+	#endif
+
+	/**
+	 * @brief   The driver supports a clipping in hardware.
+	 * @details If set to @p FALSE there is no support for non-standard queries.
+	 */
+	#ifndef GDISP_HARDWARE_CLIP
+		#define GDISP_HARDWARE_CLIP			FALSE
+	#endif
+/** @} */
+
+/**
+ * @name    GDISP software algorithm choices
+ * @{
+ */
+	/**
+	 * @brief   For filled text drawing, use a background fill and then draw
+	 *			the text instead of using a blit or direct pixel drawing.
+	 * @details If set to @p TRUE background fill and then text draw is used.
+	 * @note    This is ignored if hardware accelerated text is supported.
+	 */
+	#ifndef GDISP_SOFTWARE_TEXTFILLDRAW
+		#define GDISP_SOFTWARE_TEXTFILLDRAW		FALSE
+	#endif
+
+	/**
+	 * @brief   For filled text drawing, when using a bitmap blit
+	 *			use a column by column buffer rather than a full character
+	 *			buffer to save memory at a small performance cost.
+	 * @details If set to @p TRUE background fill one character column at a time.
+	 * @note    This is ignored if software text using blit is not being used.
+	 */
+	#ifndef GDISP_SOFTWARE_TEXTBLITCOLUMN
+		#define GDISP_SOFTWARE_TEXTBLITCOLUMN	FALSE
+	#endif
+/** @} */
+
+/**
+ * @name    GDISP pixel format choices
+ * @{
+ */
+	/**
+	 * @brief   The native pixel format for this device
+	 * @note	Should be set to one of the following:
+	 *				GDISP_PIXELFORMAT_RGB565
+	 *				GDISP_PIXELFORMAT_RGB888
+	 *				GDISP_PIXELFORMAT_RGB444
+	 *				GDISP_PIXELFORMAT_RGB332
+	 *				GDISP_PIXELFORMAT_RGB666
+	 *				GDISP_PIXELFORMAT_CUSTOM
+	 * @note	If you set GDISP_PIXELFORMAT_CUSTOM you need to also define
+	 *				color_t, RGB2COLOR(r,g,b), HTML2COLOR(h),
+	 *              RED_OF(c), GREEN_OF(c), BLUE_OF(c),
+	 *              COLOR(c) and MASKCOLOR.
+	 */
+	#ifndef GDISP_PIXELFORMAT
+		#define GDISP_PIXELFORMAT	GDISP_PIXELFORMAT_ERROR
+	#endif
+
+	/**
+	 * @brief   Do pixels require packing for a blit
+	 * @note	Is only valid for a pixel format that doesn't fill it's datatype. ie formats:
+	 *				GDISP_PIXELFORMAT_RGB888
+	 *				GDISP_PIXELFORMAT_RGB444
+	 *				GDISP_PIXELFORMAT_RGB666
+	 *				GDISP_PIXELFORMAT_CUSTOM
+	 * @note	If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills
+	 *				you need to also define @p gdispPackPixels(buf,cx,x,y,c)
+	 * @note	If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel
+	 *				format must not be a packed format as the software blit does
+	 *				not support packed pixels
+	 * @note	Very few cases should actually require packed pixels as the low
+	 *				level driver can also pack on the fly as it is sending it
+	 *				to the graphics device.
+	 */
+	#ifndef GDISP_PACKED_PIXELS
+		#define GDISP_PACKED_PIXELS			FALSE
+	#endif
+
+	/**
+	 * @brief   Do lines of pixels require packing for a blit
+	 * @note	Ignored if GDISP_PACKED_PIXELS is FALSE
+	 */
+	#ifndef GDISP_PACKED_LINES
+		#define GDISP_PACKED_LINES			FALSE
+	#endif
+/** @} */
+
+/*===========================================================================*/
+/* Define the macro's for the various pixel formats */
+/*===========================================================================*/
+
+#if defined(__DOXYGEN__)
+	/**
+	 * @brief   The color of a pixel.
+	 */
+	typedef uint16_t color_t;
+	/**
+	 * @brief   Convert a number (of any type) to a color_t.
+	 * @details Masks any invalid bits in the color
+	 */
+	#define COLOR(c)			((color_t)(c))
+	/**
+	 * @brief   Does the color_t type contain invalid bits that need masking.
+	 */
+	#define MASKCOLOR			FALSE
+	/**
+	 * @brief   Convert red, green, blue (each 0 to 255) into a color value.
+	 */
+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
+	/**
+	 * @brief   Convert a 6 digit HTML code (hex) into a color value.
+	 */
+	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
+	/**
+	 * @brief   Extract the red component (0 to 255) of a color value.
+	 */
+	#define RED_OF(c)			(((c) & 0xF800)>>8)
+	/**
+	 * @brief   Extract the green component (0 to 255) of a color value.
+	 */
+	#define GREEN_OF(c)			(((c)&0x007E)>>3)
+	/**
+	 * @brief   Extract the blue component (0 to 255) of a color value.
+	 */
+	#define BLUE_OF(c)			(((c)&0x001F)<<3)
+
+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565
+	typedef uint16_t color_t;
+	#define COLOR(c)			((color_t)(c))
+	#define MASKCOLOR			FALSE
+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
+	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
+	#define RED_OF(c)			(((c) & 0xF800)>>8)
+	#define GREEN_OF(c)			(((c)&0x07E0)>>3)
+	#define BLUE_OF(c)			(((c)&0x001F)<<3)
+
+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888
+	typedef uint32_t color_t;
+	#define COLOR(c)			((color_t)(((c) & 0xFFFFFF)))
+	#define MASKCOLOR			TRUE
+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xFF)<<16) | (((g) & 0xFF) << 8) | ((b) & 0xFF)))
+	#define HTML2COLOR(h)		((color_t)(h))
+	#define RED_OF(c)			(((c) & 0xFF0000)>>16)
+	#define GREEN_OF(c)			(((c)&0x00FF00)>>8)
+	#define BLUE_OF(c)			((c)&0x0000FF)
+
+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB444
+	typedef uint16_t color_t;
+	#define COLOR(c)			((color_t)(((c) & 0x0FFF)))
+	#define MASKCOLOR			TRUE
+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF0)<<4) | ((g) & 0xF0) | (((b) & 0xF0)>>4)))
+	#define HTML2COLOR(h)		((color_t)((((h) & 0xF00000)>>12) | (((h) & 0x00F000)>>8) | (((h) & 0x0000F0)>>4)))
+	#define RED_OF(c)			(((c) & 0x0F00)>>4)
+	#define GREEN_OF(c)			((c)&0x00F0)
+	#define BLUE_OF(c)			(((c)&0x000F)<<4)
+
+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB332
+	typedef uint8_t color_t;
+	#define COLOR(c)			((color_t)(c))
+	#define MASKCOLOR			FALSE
+	#define RGB2COLOR(r,g,b)	((color_t)(((r) & 0xE0) | (((g) & 0xE0)>>3) | (((b) & 0xC0)>>6)))
+	#define HTML2COLOR(h)		((color_t)((((h) & 0xE00000)>>16) | (((h) & 0x00E000)>>11) | (((h) & 0x0000C0)>>6)))
+	#define RED_OF(c)			((c) & 0xE0)
+	#define GREEN_OF(c)			(((c)&0x1C)<<3)
+	#define BLUE_OF(c)			(((c)&0x03)<<6)
+
+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB666
+	typedef uint32_t color_t;
+	#define COLOR(c)			((color_t)(((c) & 0x03FFFF)))
+	#define MASKCOLOR			TRUE
+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xFC)<<10) | (((g) & 0xFC)<<4) | (((b) & 0xFC)>>2)))
+	#define HTML2COLOR(h)		((color_t)((((h) & 0xFC0000)>>6) | (((h) & 0x00FC00)>>4) | (((h) & 0x0000FC)>>2)))
+	#define RED_OF(c)			(((c) & 0x03F000)>>12)
+	#define GREEN_OF(c)			(((c)&0x00FC00)>>8)
+	#define BLUE_OF(c)			(((c)&0x00003F)<<2)
+
+#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM
+	#error "GDISP: No supported pixel format has been specified."
+#endif
+
+/* Verify information for packed pixels and define a non-packed pixel macro */
+#if !GDISP_PACKED_PIXELS
+	#define gdispPackPixels(buf,cx,x,y,c)	{ ((color_t *)(buf))[(y)*(cx)+(x)] = (c); }
+#elif !GDISP_HARDWARE_BITFILLS
+	#error "GDISP: packed pixel formats are only supported for hardware accelerated drivers."
+#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888 \
+		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB444 \
+		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB666 \
+		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM
+	#error "GDISP: A packed pixel format has been specified for an unsupported pixel format."
+#endif
+
+#if GDISP_NEED_SCROLL && !GDISP_HARDWARE_SCROLL
+	#error "GDISP: Hardware scrolling is wanted but not supported."
+#endif
+
+#if GDISP_NEED_PIXELREAD && !GDISP_HARDWARE_PIXELREAD
+	#error "GDISP: Pixel read-back is wanted but not supported."
+#endif
+
+/*===========================================================================*/
+/* Driver types.                                                             */
+/*===========================================================================*/
+
+/**
+ * @brief   The type of a pixel.
+ */
+typedef color_t		pixel_t;
+/**
+ * @brief   The type of a font.
+ */
+typedef const struct font *font_t;
+/**
+ * @brief   Type for the screen orientation.
+ */
+typedef enum orientation {GDISP_ROTATE_0, GDISP_ROTATE_90, GDISP_ROTATE_180, GDISP_ROTATE_270} gdisp_orientation_t;
+/**
+ * @brief   Type for the available power modes for the screen.
+ */
+typedef enum powermode {powerOff, powerSleep, powerDeepSleep, powerOn} gdisp_powermode_t;
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	/* Core functions */
+	extern bool_t gdisp_lld_init(void);
+
+	/* Some of these functions will be implemented in software by the high level driver
+	   depending on the GDISP_HARDWARE_XXX macros defined in gdisp_lld_config.h.
+	 */
+
+	/* Drawing functions */
+	extern void gdisp_lld_clear(color_t color);
+	extern void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color);
+	extern void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+	extern void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);
+	extern void gdisp_lld_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
+
+	/* Circular Drawing Functions */
+	#if GDISP_NEED_CIRCLE
+	extern void gdisp_lld_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color);
+	extern void gdisp_lld_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color);
+	#endif
+
+	#if GDISP_NEED_ELLIPSE
+	extern void gdisp_lld_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+	extern void gdisp_lld_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+	#endif
+
+	/* Arc Drawing Functions */
+	#if GDISP_NEED_ARC
+	extern void gdisp_lld_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
+	extern void gdisp_lld_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
+	#endif
+
+	/* Text Rendering Functions */
+	#if GDISP_NEED_TEXT
+	extern void gdisp_lld_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color);
+	extern void gdisp_lld_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
+	#endif
+
+	/* Pixel readback */
+	#if GDISP_NEED_PIXELREAD
+	extern color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y);
+	#endif
+
+	/* Scrolling Function - clears the area scrolled out */
+	#if GDISP_NEED_SCROLL
+	extern void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
+	#endif
+
+	/* Set driver specific control */
+	#if GDISP_NEED_CONTROL
+	extern void gdisp_lld_control(unsigned what, void *value);
+	#endif
+
+	/* Query driver specific data */
+	extern void *gdisp_lld_query(unsigned what);
+
+	/* Clipping Functions */
+	#if GDISP_NEED_CLIP
+	extern void gdisp_lld_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy);
+	#endif
+
+	/* Messaging API */
+	#if GDISP_NEED_MSGAPI
+	#include "gdisp_lld_msgs.h"
+	extern void gdisp_lld_msg_dispatch(gdisp_lld_msg_t *msg);
+	#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* GFX_USE_GDISP */
+
+#endif	/* _GDISP_LLD_H */
+/** @} */
+
diff --git a/include/gdisp/lld/gdisp_lld_msgs.h b/include/gdisp/lld/gdisp_lld_msgs.h
index 6fe78567..f6055fd5 100644
--- a/include/gdisp/lld/gdisp_lld_msgs.h
+++ b/include/gdisp/lld/gdisp_lld_msgs.h
@@ -1,193 +1,193 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    ChibiOS/GFX is free software; you can redistribute it and/or modify

-    it under the terms of the GNU General Public License as published by

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file	include/gdisp/lld/gdisp_lld_msgs.h

- * @brief   GDISP Graphic Driver subsystem low level driver message structures.

- *

- * @addtogroup GDISP

- * @{

- */

-

-#ifndef _GDISP_LLD_MSGS_H

-#define _GDISP_LLD_MSGS_H

-

-/* This file describes the message API for gdisp_lld */

-#if GFX_USE_GDISP && GDISP_NEED_MSGAPI

-

-typedef enum gdisp_msgaction {

-	GDISP_LLD_MSG_NOP,

-	GDISP_LLD_MSG_INIT,

-	GDISP_LLD_MSG_CLEAR,

-	GDISP_LLD_MSG_DRAWPIXEL,

-	GDISP_LLD_MSG_FILLAREA,

-	GDISP_LLD_MSG_BLITAREA,

-	GDISP_LLD_MSG_DRAWLINE,

-	#if GDISP_NEED_CLIP

-		GDISP_LLD_MSG_SETCLIP,

-	#endif

-	#if GDISP_NEED_CIRCLE

-		GDISP_LLD_MSG_DRAWCIRCLE,

-		GDISP_LLD_MSG_FILLCIRCLE,

-	#endif

-	#if GDISP_NEED_ELLIPSE

-		GDISP_LLD_MSG_DRAWELLIPSE,

-		GDISP_LLD_MSG_FILLELLIPSE,

-	#endif

-	#if GDISP_NEED_ARC

-		GDISP_LLD_MSG_DRAWARC,

-		GDISP_LLD_MSG_FILLARC,

-	#endif

-	#if GDISP_NEED_TEXT

-		GDISP_LLD_MSG_DRAWCHAR,

-		GDISP_LLD_MSG_FILLCHAR,

-	#endif

-	#if GDISP_NEED_PIXELREAD

-		GDISP_LLD_MSG_GETPIXELCOLOR,

-	#endif

-	#if GDISP_NEED_SCROLL

-		GDISP_LLD_MSG_VERTICALSCROLL,

-	#endif

-	#if GDISP_NEED_CONTROL

-		GDISP_LLD_MSG_CONTROL,

-	#endif

-	GDISP_LLD_MSG_QUERY,

-} gdisp_msgaction_t;

-

-typedef union gdisp_lld_msg {

-	gdisp_msgaction_t	action;

-	struct gdisp_lld_msg_init {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_INIT

-	} init;

-	struct gdisp_lld_msg_clear {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_CLEAR

-		color_t				color;

-	} clear;

-	struct gdisp_lld_msg_drawpixel {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWPIXEL

-		coord_t				x, y;

-		color_t				color;

-	} drawpixel;

-	struct gdisp_lld_msg_fillarea {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLAREA

-		coord_t				x, y;

-		coord_t				cx, cy;

-		color_t				color;

-	} fillarea;

-	struct gdisp_lld_msg_blitarea {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_BLITAREA

-		coord_t				x, y;

-		coord_t				cx, cy;

-		coord_t				srcx, srcy;

-		coord_t				srccx;

-		const pixel_t		*buffer;

-	} blitarea;

-	struct gdisp_lld_msg_setclip {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_SETCLIP

-		coord_t				x, y;

-		coord_t				cx, cy;

-	} setclip;

-	struct gdisp_lld_msg_drawline {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWLINE

-		coord_t				x0, y0;

-		coord_t				x1, y1;

-		color_t				color;

-	} drawline;

-	struct gdisp_lld_msg_drawcircle {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCIRCLE

-		coord_t				x, y;

-		coord_t				radius;

-		color_t				color;

-	} drawcircle;

-	struct gdisp_lld_msg_fillcircle {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLCIRCLE

-		coord_t				x, y;

-		coord_t				radius;

-		color_t				color;

-	} fillcircle;

-	struct gdisp_lld_msg_drawellipse {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWELLIPSE

-		coord_t				x, y;

-		coord_t				a, b;

-		color_t				color;

-	} drawellipse;

-	struct gdisp_lld_msg_fillellipse {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLELLIPSE

-		coord_t				x, y;

-		coord_t				a, b;

-		color_t				color;

-	} fillellipse;

-	struct gdisp_lld_msg_drawarc {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWARC

-		coord_t				x, y;

-		coord_t				radius;

-		coord_t				startangle, endangle;

-		color_t				color;

-	} drawcircle;

-	struct gdisp_lld_msg_fillarc {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLARC

-		coord_t				x, y;

-		coord_t				radius;

-		coord_t				startangle, endangle;

-		color_t				color;

-	} fillcircle;

-	struct gdisp_lld_msg_drawchar {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCHAR

-		coord_t				x, y;

-		char				c;

-		font_t				font;

-		color_t				color;

-	} drawchar;

-	struct gdisp_lld_msg_fillchar {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLCHAR

-		coord_t				x, y;

-		char				c;

-		font_t				font;

-		color_t				color;

-		color_t				bgcolor;

-	} fillchar;

-	struct gdisp_lld_msg_getpixelcolor {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_GETPIXELCOLOR

-		coord_t				x, y;

-		color_t				result;

-	} getpixelcolor;

-	struct gdisp_lld_msg_verticalscroll {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_VERTICALSCROLL

-		coord_t				x, y;

-		coord_t				cx, cy;

-		int					lines;

-		color_t				bgcolor;

-	} verticalscroll;

-	struct gdisp_lld_msg_control {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_CONTROL

-		int					what;

-		void *				value;

-	} control;

-	struct gdisp_lld_msg_query {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_QUERY

-		int					what;

-		void *				result;

-	} query;

-} gdisp_lld_msg_t;

-

-#endif	/* GFX_USE_GDISP && GDISP_NEED_MSGAPI */

-#endif	/* _GDISP_LLD_MSGS_H */

-/** @} */

-

+/*
+    ChibiOS/GFX - Copyright (C) 2012
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file	include/gdisp/lld/gdisp_lld_msgs.h
+ * @brief   GDISP Graphic Driver subsystem low level driver message structures.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#ifndef _GDISP_LLD_MSGS_H
+#define _GDISP_LLD_MSGS_H
+
+/* This file describes the message API for gdisp_lld */
+#if GFX_USE_GDISP && GDISP_NEED_MSGAPI
+
+typedef enum gdisp_msgaction {
+	GDISP_LLD_MSG_NOP,
+	GDISP_LLD_MSG_INIT,
+	GDISP_LLD_MSG_CLEAR,
+	GDISP_LLD_MSG_DRAWPIXEL,
+	GDISP_LLD_MSG_FILLAREA,
+	GDISP_LLD_MSG_BLITAREA,
+	GDISP_LLD_MSG_DRAWLINE,
+	#if GDISP_NEED_CLIP
+		GDISP_LLD_MSG_SETCLIP,
+	#endif
+	#if GDISP_NEED_CIRCLE
+		GDISP_LLD_MSG_DRAWCIRCLE,
+		GDISP_LLD_MSG_FILLCIRCLE,
+	#endif
+	#if GDISP_NEED_ELLIPSE
+		GDISP_LLD_MSG_DRAWELLIPSE,
+		GDISP_LLD_MSG_FILLELLIPSE,
+	#endif
+	#if GDISP_NEED_ARC
+		GDISP_LLD_MSG_DRAWARC,
+		GDISP_LLD_MSG_FILLARC,
+	#endif
+	#if GDISP_NEED_TEXT
+		GDISP_LLD_MSG_DRAWCHAR,
+		GDISP_LLD_MSG_FILLCHAR,
+	#endif
+	#if GDISP_NEED_PIXELREAD
+		GDISP_LLD_MSG_GETPIXELCOLOR,
+	#endif
+	#if GDISP_NEED_SCROLL
+		GDISP_LLD_MSG_VERTICALSCROLL,
+	#endif
+	#if GDISP_NEED_CONTROL
+		GDISP_LLD_MSG_CONTROL,
+	#endif
+	GDISP_LLD_MSG_QUERY,
+} gdisp_msgaction_t;
+
+typedef union gdisp_lld_msg {
+	gdisp_msgaction_t	action;
+	struct gdisp_lld_msg_init {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_INIT
+	} init;
+	struct gdisp_lld_msg_clear {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_CLEAR
+		color_t				color;
+	} clear;
+	struct gdisp_lld_msg_drawpixel {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWPIXEL
+		coord_t				x, y;
+		color_t				color;
+	} drawpixel;
+	struct gdisp_lld_msg_fillarea {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLAREA
+		coord_t				x, y;
+		coord_t				cx, cy;
+		color_t				color;
+	} fillarea;
+	struct gdisp_lld_msg_blitarea {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_BLITAREA
+		coord_t				x, y;
+		coord_t				cx, cy;
+		coord_t				srcx, srcy;
+		coord_t				srccx;
+		const pixel_t		*buffer;
+	} blitarea;
+	struct gdisp_lld_msg_setclip {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_SETCLIP
+		coord_t				x, y;
+		coord_t				cx, cy;
+	} setclip;
+	struct gdisp_lld_msg_drawline {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWLINE
+		coord_t				x0, y0;
+		coord_t				x1, y1;
+		color_t				color;
+	} drawline;
+	struct gdisp_lld_msg_drawcircle {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCIRCLE
+		coord_t				x, y;
+		coord_t				radius;
+		color_t				color;
+	} drawcircle;
+	struct gdisp_lld_msg_fillcircle {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLCIRCLE
+		coord_t				x, y;
+		coord_t				radius;
+		color_t				color;
+	} fillcircle;
+	struct gdisp_lld_msg_drawellipse {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWELLIPSE
+		coord_t				x, y;
+		coord_t				a, b;
+		color_t				color;
+	} drawellipse;
+	struct gdisp_lld_msg_fillellipse {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLELLIPSE
+		coord_t				x, y;
+		coord_t				a, b;
+		color_t				color;
+	} fillellipse;
+	struct gdisp_lld_msg_drawarc {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWARC
+		coord_t				x, y;
+		coord_t				radius;
+		coord_t				startangle, endangle;
+		color_t				color;
+	} drawarc;
+	struct gdisp_lld_msg_fillarc {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLARC
+		coord_t				x, y;
+		coord_t				radius;
+		coord_t				startangle, endangle;
+		color_t				color;
+	} fillarc;
+	struct gdisp_lld_msg_drawchar {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCHAR
+		coord_t				x, y;
+		char				c;
+		font_t				font;
+		color_t				color;
+	} drawchar;
+	struct gdisp_lld_msg_fillchar {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLCHAR
+		coord_t				x, y;
+		char				c;
+		font_t				font;
+		color_t				color;
+		color_t				bgcolor;
+	} fillchar;
+	struct gdisp_lld_msg_getpixelcolor {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_GETPIXELCOLOR
+		coord_t				x, y;
+		color_t				result;
+	} getpixelcolor;
+	struct gdisp_lld_msg_verticalscroll {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_VERTICALSCROLL
+		coord_t				x, y;
+		coord_t				cx, cy;
+		int					lines;
+		color_t				bgcolor;
+	} verticalscroll;
+	struct gdisp_lld_msg_control {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_CONTROL
+		int					what;
+		void *				value;
+	} control;
+	struct gdisp_lld_msg_query {
+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_QUERY
+		int					what;
+		void *				result;
+	} query;
+} gdisp_lld_msg_t;
+
+#endif	/* GFX_USE_GDISP && GDISP_NEED_MSGAPI */
+#endif	/* _GDISP_LLD_MSGS_H */
+/** @} */
+
diff --git a/include/gfx_rules.h b/include/gfx_rules.h
index c132de54..ce6bea50 100644
--- a/include/gfx_rules.h
+++ b/include/gfx_rules.h
@@ -1,128 +1,136 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    ChibiOS/GFX is free software; you can redistribute it and/or modify

-    it under the terms of the GNU General Public License as published by

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file    include/gfx_rules.h

- * @brief   GFX system safety rules header file.

- *

- * @addtogroup GFX

- * @{

- */

-

-#ifndef _GFX_RULES_H

-#define _GFX_RULES_H

-

-/**

- * Safety checks on all the defines.

- *

- * These are defined in the order of their inter-dependancies.

- */

-

-#if GFX_USE_GWIN

-	#if !GFX_USE_GDISP

-		#error "GWIN: GFX_USE_GDISP must be TRUE when using GWIN"

-	#endif

-	#if !GDISP_NEED_CLIP

-		#warning "GWIN: Drawing can occur outside the defined windows as GDISP_NEED_CLIP is FALSE"

-	#endif

-	#if GWIN_NEED_BUTTON

-		#if !GDISP_NEED_TEXT

-			#error "GWIN: GDISP_NEED_TEXT is required if GWIN_NEED_BUTTON is TRUE."

-		#endif

-		#if !GFX_USE_GEVENT

-			#warning "GWIN: GFX_USE_GEVENT is required if GWIN_NEED_BUTTON is TRUE. It has been turned on for you."

-			#undef GFX_USE_GEVENT

-			#define GFX_USE_GEVENT	TRUE

-		#endif

-		#if !GFX_USE_GINPUT || !(GINPUT_NEED_MOUSE || GINPUT_NEED_TOGGLE)

-			#warning "GWIN: You have set GWIN_NEED_BUTTON to TRUE but no supported GINPUT (mouse/toggle) devices have been included"

-		#endif

-		#if !GDISP_NEED_MULTITHREAD && !GDISP_NEED_ASYNC

-			#warning "GWIN: Either GDISP_NEED_MULTITHREAD or GDISP_NEED_ASYNC is required if GWIN_NEED_BUTTON is TRUE."

-			#warning "GWIN: GDISP_NEED_MULTITHREAD has been turned on for you."

-			#undef GDISP_NEED_MULTITHREAD

-			#define GDISP_NEED_MULTITHREAD	TRUE

-		#endif

-	#endif

-	#if GWIN_NEED_CONSOLE

-		#if !GDISP_NEED_TEXT

-			#error "GWIN: GDISP_NEED_TEXT is required if GWIN_NEED_CONSOLE is TRUE."

-		#endif

-	#endif

-	#if GWIN_NEED_GRAPH

-	#endif

-#endif

-

-#if GFX_USE_GINPUT

-	#if !GFX_USE_GEVENT

-		#warning "GINPUT: GFX_USE_GEVENT is required if GFX_USE_GINPUT is TRUE. It has been turned on for you."

-		#undef GFX_USE_GEVENT

-		#define	GFX_USE_GEVENT		TRUE

-	#endif

-	#if !GFX_USE_GTIMER

-		#warning "GINPUT: GFX_USE_GTIMER is required if GFX_USE_GINPUT is TRUE. It has been turned on for you."

-		#undef GFX_USE_GTIMER

-		#define	GFX_USE_GTIMER		TRUE

-	#endif

-#endif

-

-#if GFX_USE_GDISP

-	#if GDISP_NEED_MULTITHREAD && GDISP_NEED_ASYNC

-		#error "GDISP: Only one of GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC should be defined."

-	#endif

-	#if GDISP_NEED_ASYNC

-		#if !GDISP_NEED_MSGAPI

-			#warning "GDISP: Messaging API is required for Async Multi-Thread. It has been turned on for you."

-			#undef GDISP_NEED_MSGAPI

-			#define GDISP_NEED_MSGAPI	TRUE

-		#endif

-	#endif

-#endif

-

-#if GFX_USE_TDISP

-#endif

-

-#if GFX_USE_GEVENT

-	#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES

-		#error "GEVENT: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"

-	#endif

-#endif

-

-#if GFX_USE_GTIMER

-	#if GFX_USE_GDISP && !GDISP_NEED_MULTITHREAD && !GDISP_NEED_ASYNC

-		#warning "GTIMER: Neither GDISP_NEED_MULTITHREAD nor GDISP_NEED_ASYNC has been specified."

-		#warning "GTIMER: Make sure you are not performing any GDISP/GWIN drawing operations in the timer callback!"

-	#endif

-#endif

-

-#if GFX_USE_GAUDIN

-#endif

-

-#if GFX_USE_GAUDOUT

-#endif

-

-#if GFX_USE_GADC

-#endif

-

-#if GFX_USE_GMISC

-#endif

-

-#endif /* _GFX_H */

-/** @} */

+/*
+    ChibiOS/GFX - Copyright (C) 2012
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    include/gfx_rules.h
+ * @brief   GFX system safety rules header file.
+ *
+ * @addtogroup GFX
+ * @{
+ */
+
+#ifndef _GFX_RULES_H
+#define _GFX_RULES_H
+
+/**
+ * Safety checks on all the defines.
+ *
+ * These are defined in the order of their inter-dependancies.
+ */
+
+#if GFX_USE_GWIN
+	#if !GFX_USE_GDISP
+		#error "GWIN: GFX_USE_GDISP must be TRUE when using GWIN"
+	#endif
+	#if !GDISP_NEED_CLIP
+		#warning "GWIN: Drawing can occur outside the defined windows as GDISP_NEED_CLIP is FALSE"
+	#endif
+	#if GWIN_NEED_BUTTON
+		#if !GDISP_NEED_TEXT
+			#error "GWIN: GDISP_NEED_TEXT is required if GWIN_NEED_BUTTON is TRUE."
+		#endif
+		#if !GFX_USE_GEVENT
+			#warning "GWIN: GFX_USE_GEVENT is required if GWIN_NEED_BUTTON is TRUE. It has been turned on for you."
+			#undef GFX_USE_GEVENT
+			#define GFX_USE_GEVENT	TRUE
+		#endif
+		#if !GFX_USE_GINPUT || !(GINPUT_NEED_MOUSE || GINPUT_NEED_TOGGLE)
+			#warning "GWIN: You have set GWIN_NEED_BUTTON to TRUE but no supported GINPUT (mouse/toggle) devices have been included"
+		#endif
+		#if !GDISP_NEED_MULTITHREAD && !GDISP_NEED_ASYNC
+			#warning "GWIN: Either GDISP_NEED_MULTITHREAD or GDISP_NEED_ASYNC is required if GWIN_NEED_BUTTON is TRUE."
+			#warning "GWIN: GDISP_NEED_MULTITHREAD has been turned on for you."
+			#undef GDISP_NEED_MULTITHREAD
+			#define GDISP_NEED_MULTITHREAD	TRUE
+		#endif
+	#endif
+	#if GWIN_NEED_CONSOLE
+		#if !GDISP_NEED_TEXT
+			#error "GWIN: GDISP_NEED_TEXT is required if GWIN_NEED_CONSOLE is TRUE."
+		#endif
+	#endif
+	#if GWIN_NEED_GRAPH
+	#endif
+#endif
+
+#if GFX_USE_GINPUT
+	#if !GFX_USE_GEVENT
+		#warning "GINPUT: GFX_USE_GEVENT is required if GFX_USE_GINPUT is TRUE. It has been turned on for you."
+		#undef GFX_USE_GEVENT
+		#define	GFX_USE_GEVENT		TRUE
+	#endif
+	#if !GFX_USE_GTIMER
+		#warning "GINPUT: GFX_USE_GTIMER is required if GFX_USE_GINPUT is TRUE. It has been turned on for you."
+		#undef GFX_USE_GTIMER
+		#define	GFX_USE_GTIMER		TRUE
+	#endif
+#endif
+
+#if GFX_USE_GDISP
+	#if GDISP_NEED_MULTITHREAD && GDISP_NEED_ASYNC
+		#error "GDISP: Only one of GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC should be defined."
+	#endif
+	#if GDISP_NEED_ASYNC
+		#if !GDISP_NEED_MSGAPI
+			#warning "GDISP: Messaging API is required for Async Multi-Thread. It has been turned on for you."
+			#undef GDISP_NEED_MSGAPI
+			#define GDISP_NEED_MSGAPI	TRUE
+		#endif
+	#endif
+#endif
+
+#if GFX_USE_TDISP
+#endif
+
+#if GFX_USE_GADC
+	#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
+		#error "GADC: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
+	#endif
+	#if !GFX_USE_GTIMER
+		#warning "GADC: GFX_USE_GTIMER is required if GFX_USE_GADC is TRUE. It has been turned on for you."
+		#undef GFX_USE_GTIMER
+		#define	GFX_USE_GTIMER		TRUE
+	#endif
+#endif
+
+#if GFX_USE_GEVENT
+	#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
+		#error "GEVENT: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
+	#endif
+#endif
+
+#if GFX_USE_GTIMER
+	#if GFX_USE_GDISP && !GDISP_NEED_MULTITHREAD && !GDISP_NEED_ASYNC
+		#warning "GTIMER: Neither GDISP_NEED_MULTITHREAD nor GDISP_NEED_ASYNC has been specified."
+		#warning "GTIMER: Make sure you are not performing any GDISP/GWIN drawing operations in the timer callback!"
+	#endif
+#endif
+
+#if GFX_USE_GAUDIN
+#endif
+
+#if GFX_USE_GAUDOUT
+#endif
+
+#if GFX_USE_GMISC
+#endif
+
+#endif /* _GFX_H */
+/** @} */